The LLVM JIT API has changed many times over the years. However, the official tutorials have failed to keep up. This project aims to update the official “Building a JIT” tutorials to use the latest version of the OrcJIT API and add new content that might be relevant to new LLLVM users interested in writing their own JIT compilers.
The current implementation of series expansions in SymPy is developed to a large extent, but not complete. There are a few limit failures that need to be addressed, for which the series module is the backbone. This project aims to fix the computation of leading term methods and make them more robust, which will fix many outstanding issues. This project will also add series and asymptotic expansions support to all special functions, and fix some long standing issues with AccumulationBounds and Order terms.
Linux provides two message queue implementations, System V message queues, and POSIX message queues, none of which are currently implemented in gVisor. This project aims to extend gVisor by implementing a minimal version of System V message queues
The project focuses on working in Message view events and Authentication areas. They are Adding configurability for stream typing indicators, Adding read indicators, Adding general OAuth2, re-Authentication and a few others.
Create a web application that integrates with an existing buildbot infrastructure to fully automatically track the performance of many aspects of Halide over time, including but not limited to compile times, code size, memory footprint (RSS and stack usage), and execution speed for both the compiler proper and the optimized pipelines. When evaluating a pull request, a clear visualization can ensure you notice whether there is any metric changed at a glance.
This project aims to implement the CoAP endpoint library for the drogue-cloud project. The endpoint would have the ability to facilitate the publishing of data to an HTTP endpoint (device-to-cloud) and send commands to a device from an HTTP endpoint (cloud-to-device). The project would involve implementing the above cloud side features and test them end to end. This project does not focus on implementing a CoAP client.
Buildpacks are pluggable tools that can be used to transform the source code to OCI compliant images (Docker images) that can run on any cloud. It is a Cloud Native Computing Foundation incubating project that provides a higher level of abstraction compared to Dockerfiles, decoupling the entire operational overhead and automating the process of rendering the applications production-ready. Currently, we don’t have the mechanism to inform the Buildpack Registry Index and Buildpack Registry Namespace repositories if they are updated with the latest Github Actions version or not. Through this project, we aim to accomplish automatically Automating Pull Request to Staging Index - whenever a new version of the github-action repo is released by automating staging tests of new action versions.
ABioTrans Plus is a web server for transcriptome data analysis and visualization. It supports the analysis of microarray and RNASeq data and performs ten different bio-statistical analyses that cover the common analytics for gene expression data. Furthermore, it gives the users access to several bioinformatics tools to perform 12 different bioinformatics analyses on gene/protein datasets. This project aims to develop ABioTrans Plus v3.0 which will support a wider range of high throughput omics data, namely MS-based proteomics and metabolomics data. Furthermore, developing a detailed report with the performed analysis with figures and data ready to be included in the publications. Machine learning is a method of data analysis that automates analytical model building. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention. Machine learning has been used broadly in biological studies for prediction and discovery.
This Project involves making the ODK-X Services Application meet the current UI/UX standards by redesigning the Basic Application Architecture and improving the User Experience of various features provided by the Application, with major emphasis on simplifying the Authentication Workflow.
A dart version of casbin to support access models like ACL, RBAC, ABAC and others.
Allow building Gentoo stages and boot media for other architectures in a robust manner, with increased security and reliability.
Data structures that complex networks (graphs) can model are present almost everywhere. Therefore, it is important to have a software that can visualize and provide insights into such structures. Unfortunately, the vast majority of network visualization and manipulation softwares currently available has several limitations. For example, Gephi (Java) does not scale well when the number of nodes increases and cannot deal with 3d layout algorithms natively. Because of those limitations in the currently available network visualization softwares, we propose to develop a client/server network visualization for FURY. Our proposed system is inspired by the following work: “Harnessing WebGL and WebSockets for a Web-Based Collaborative Graph Exploration Tool”.
This project aims to add a right sidebar to the minimal Hydrogen matrix client that shows :
The main focus will be on frontend-related issues particularly, compose features, message area, user interface. Besides that, I’ll work on fixing the issues labeled as bugs. I’m also interested in making the CSS more organized.
The plan is to make the user experience more user-friendly and bug-free. Here is the current list of issues and features that I plan to complete in this project.
It is highly unpredictable to guess what issues might come up later. So, the main outline will be to solve any new issue that might get opened later which is related to the frontend, compose box, message area with the ultimate goal of making Zulip much better than before.
FOSSology’s build system is based on multilevel makefiles that work together to provide a build infrastructure for the project. Although make is a robust build system but it is too outdated and slow compared to modern build systems. Although build configurations are not supposed to be updated as often as source files, there are few noticeable problems with make. This project will migrate the build system to more user freindly and popular CMake.
Fossology has been using free Travis CI for all its continuous builds, tests and deployment purposes throughout the organization. GitHub Actions provides better integration, faster build times and is versatile in many other ways. This projects aims at improving the overall CI/CD for the project as well as upgrade the targets and virtual platforms to the latest compatible versions.
While libraries with robust time-series forecasting capability exist in languages like R and Python, one with similar ease-of-use and functionality does not exist in Julia. The goal of this project is to develop and extend Pythia, a Julia library for time-series forecasting. Specifically, Pythia will include common forecasting algorithms (e.g., ETS, Croston's Method, etc.), evaluation metrics, and plotting capabilities. Additionally, Pythia will be compatible with the MLJ ecosystem.
Inspired by forecast, fable, statsmodels, sktime, Pythia will compile a variety of important functions for time series forecasting into one unified interface.
The goal of this project is to implement the MuZero algorithm in Julia, with the following expected benefits:
The City of Boston’s Parks Department maintains a comprehensive data set on trees in Boston. However, it’s a manual and laborious process to get the data (such as conducting site visits for tree counts) on a regular basis. We would like to explore the use of satellite and aerial imagery to get a regularly updated census of trees across the city. We would also like to look at the feasibility of determining tree health and the variety of tree species across the city.
The ideal outcome would be 1) the creation of a new, accurate machine learning model focused on urban tree canopies, 2) the creation of a simple web interface for the Parks Department to upload new aerial imagery for analysis, and 3) the ability to the Parks Department to generate a list of statistics on tree counts to ensure that it continues to plants trees in an equitable manner across the city.
Coccinelle is a C-program matching and transformation tool developed for C programmers to write intuitive code manipulation rules. This tool was initially released for Linux developers who send patches on mailing lists, but it can also be applied to other projects. To describe matching and transformation rules in the source code with a patch-like appearance, Coccinelle employs a domain specific language called the Semantic Patch Language (SmPL), and attempts to manipulate the given C code based on the given SmPL rule. Although SmPL can provide many useful matching and transformation features, there are limits to the C matching patterns that the SmPL grammar can express due to the complexity of the C grammar. This is particularly the case for function headers, that involve complex types, annotations, etc that have been somewhat less tested by the users of Coccinelle. This project will study the current status and limitations of the handleability of function headers by designing and running a script that checks whether each function header in a given project can be parsed correctly and applying it to the latest Linux kernel. Based on the results, any detected problems will be fixed.
Currently CVE Binary Tool’s binary scanning is slow and a software manifest of known packages can be used for quick scanning for CVEs as an early warning system. Here a database is built primarily of top packages from PyPI and the core packages of popular Linux distros like Ubuntu, Fedora, CentOS etc. and a parser that reads the packages from the list and maps them with the database. The checkers for these packages are created alongside.
Also to improve user experience the creation of a backported fix checking utility can be made. It checks the packages with CVE in the scan and a database with the data including backported fix and provides an output if the CVE is fixed.
Quark-Engine is a rule-based android malware detection tool, However, as a contributor of both Quark and its side projects (quark-rule-generate, ruleviewer), we know that Quark currently faces a problem of insufficient number of detection rules. Although Quark-Engine has a side project for automatically generating rules, the performance of generating detection rules is still low, and the multi-process technique used in this project still has problems. Thus, my first object of this proposal is to develop and implement a new strategy for the rule generation technique to improve the efficiency of rule generation and solve the multi-process issues.
Furthermore, the Quark team is now executing a strategy called “Quark Everywhere” which is to expand the influence of Quark among security open source projects. Thus, my second object of this proposal is to help Quark-Engine integrate with other security open-source projects and improve user experiences of Quark-related functionalities to the integrated projects (APKLab, Jadx).
The proposal for GSoC - Zulip aims to improve the overall experience of the Zulip web app by means of implementing full stack features such as send later feature, remind about message feature, clear status text after time feature, deny guest users access to other users, etc. I would like to see Zulip able to cater the needs of its growing user base by implementing features essential for a smooth and high-performance team chat system.
Improve the TX capabilities of SatNOGS using Gnu Radio and C++
Eye tracking has many applications from driver safety to improved accessibility for people with disabilities. There exist expensive and bulky hardware solutions for eye tracking but this project aims to bring robust and accurate eye tracking to everyone. Recent research and the pervasiveness of handheld devices with powerful cameras have now made it easy to have high quality eye tracking right in our pockets!
The aim of this project is to allow researchers and developers all over the world to use our open-sourced eye tracker (with additional features) in new and varied use cases. From simple systems where the phone can be mounted on a stand in a vehicle to track multiple parameters of the driver – drowsiness, gaze, attentiveness to more complex applications like emotion analysis and even lie detection, the sky's the limit.
Boost.Real aims at providing a data-type that can represent all types of computable real numbers and provides the flexibility of performing arbitrary precision arithmetic, the user can always decide and control the amount of precision to be used for a calculation thus controlling the computational power used by the machine. I propose to benchmark the library and compare it against other similar libraries. There is a scope of optimization for Trigonometric functions and performance can be improved by a significant amount. I also plan for several other small optimizations
The primary aim of this project is to enhance Zulip’s Rest API Documentation and to fill the gaps currently present in the documentation. Zulip has a nice framework for writing API Documentation based on the OpenAPI standard with built-in automated tests, but there is a lot of scope in improving the quality of the documentation and how it is presented to the user. Some tasks include generating API pages directly from OpenAPI data, improving the organisation and UI of /register and /events endpoint, adding support for auto-generated API bindings, documenting currently undocumented /api endpoints and fixing the currently open issues related to API Docs area, as well as doing minor API refactoring with appropriate documentation updates.
TARDIS displays logs during the simulation which consists of values of different mathematical variables and the state of the simulation. This is done so that the user can keep track of the convergence of the simulation. However, the user experience can be enhanced by displaying more relevant log messages and displaying the convergence in plots in real-time. This project aims to provide a dedicated logging framework and plots to display the convergence of the simulation in real-time. Apart from that, this project also aims to complete the Monte Carlo Visualisation Project that was put on hold and to add a Dash based dashboard containing all convergence plots for a better simulation tracking experience.
Synthesis is at the heart of organic chemistry. It is the process of constructing a molecule through a series of reactions. Efficient molecular synthesis is significant, especially in areas like medicinal chemistry. However, it can be challenging to plan a synthesis for a complex molecule.
Retrosynthesis is an iterative process of breaking down a target molecule into a series of simpler molecules which are readily available. It provides a systematic way to plan a chemical synthesis. But, as the space of possible chemical reactions is vast, it is hard for chemists to make the right disconnections while optimizing for multiple factors such as the cost of precursors and efficiency of the reaction.
At its heart, the challenge of making a single retrosynthesis prediction can be recast as a Machine Translation task. Consequently, Natural Language Processing techniques can be leveraged to tackle this using Deep Learning.
This project is focused on extending the DeepChem Library to support Retrosynthesis models, specifically to make single step predictions. This will be achieved by implementing a Molecular Transformer model and enhancing support for Reaction datasets.
Tensorflow GAN is a lightweight library that provides a convenient way to train and evaluate GAN models. Through this project different variants of GAN models will be implemented and trained using Tf-GAN, and will be added as examples to the library. Additionally multiple Colab notebooks will also be added, demonstrating the performances of each of the example models in a more appealing manner to the users. This project is aimed at providing users a more convenient way to understand the benefits of using Tf-GANs, encouraging them to make use of the library.
Netlink proposal - motivation, work done
BoB Robotics is an open-source robotics framework in C++, for interfacing hardware with various robot platforms and software tools for running simulation and visualizing data. As a part of the project, I plan to work on the problem of sensor fusion using BoB robotics and Gazebo, to investigate suitable sensor fusion methods for integrating various conventional and bio-inspired sensors. The broad deliverables I plan to achieve during over summer are:
I will continue from last year’s work and improve the clustering algorithm to the in-production code and enhance the previous work. The main problem is to find the correct anchor. For this, I want to propose a celeb detection API of Microsoft azure which is the best for this use case. Currently, the most time-consuming process in the program is going frame by frame and extracting faces. The face-recognition method used in the production code processes each frame individually. I want to upgrade it to a parallelized algorithm to process multiple frames in a batch and increase the processing speed exponentially, which will also help in faster testing of hyperparameters. Batch processing can be much quicker than processing single images at a time. So I think we use batch processing for multi-threading.
This project revolves around designing a reusable framework for mocking the driver side of a VirtQueue operation. It would allow rust-vmm crates and other projects to use it and would provide a cleaner alternative to mocking code already found in vm-virtio.
The framework would at first provide users with more granular control over mocking what the driver will place in the queue and will later support mocking more advanced features such as notification suppression, indirect descriptors and other device specific features.
Currently, the FreeBSD virtual terminal driver vt(4) does not support inputting CJK characters directly in the virtual terminal, so our project idea is to provide an environment that can run IME (input method editor) in the console.
A common usage scenario is when a user wants to create a user with the user info description in Chinese during the system installation. Since the installation process must proceed in a virtual console, there is no way to open an IME window to input CJK characters.
Another example is hosting a FreeBSD server on a cloud platform or a virtual machine. When one wants to do some simple admin routines on the machine or disconnects from the SSH session, he/she needs to do some configurations and keeps records or takes notes on the server. It's sometimes quite inconvenient for those CJK writing-system users to write texts in their most familiar languages.
And we want to implement similar features of those IME (fcitx, ibus) but in the console.
Enhance interoperability in the current Jenkins architecture by designing a plugin for Jenkins which emits and consumes CloudEvents. CloudEvents is an industry-adopted standard specification for describing event and event data (also referred to as Payload). This project enables Jenkins to produce CloudEvents (as a source) for common Jenkins events like a project build success/failure, which other tools (example Azure Event Grid) can consume. This project also enables Jenkins to be configured as a sink where external tools (example Amazon Kinesis) can send CloudEvents, and Jenkins can consume those events to perform a Jenkins action. Implementing this plugin in a workflow will give Jenkins users the ability to use and extend an event-driven Jenkins workflow to systems which use CloudEvents for defining their events.
Nowadays, Ceph supports Kafka, HTTP and AMQP(ver 0.9.1) endpoints natively from the Ceph Rados Gateway. However, to allow for a large variety of endpoint types to integrate with Ceph, we are encountered with some inconvenience on these various protocols from different service infrastructure. The workaround for the notification brings the burden of adaptor deployment, communication and translation overhead.
AMQP 1.0 is the latest standard for AMQP. It focuses on core features which are necessary for interoperability at Internet scale, and it contains less explicit routing than previous versions. Even though Ceph has supported the AMQP(ver 0.9.1) natively, the gap between these two protocol specifications cannot be ignored. The next level AMQP(ver 1.0) requires a completely different client library. AMQP 1.0 brokers are supported by Apache Qpid/ActiveMQ project and Azure platform, etc.
To address this problem, we should support the AMQP 1.0 natively in the Ceph Rados Gateway. This requires adding the qpid-proton client library to the Rados Gateway code base, and use it to send notifications to AMQP 1.0 compatible brokers.
Chrome OS enables fast and relatively low energy-consuming by utilizing TensorFlow Lite and hardware ML accelerators. The hardware accelerators are great and give good performance in terms of model inference. However, not all operators will be implemented by hardware. And in this case, we need to fallback to a generic solution (CPU backend) to guarantee the model will get run successfully.
The key is to implement a high-performance and stable CPU backend and XNNPACK gives us the opportunity to do so by simply porting its implementation to Chrome OS codebase and align the API and internal calls with our NNAPI.
By porting the most commonly used ops to Chrome OS in XNNPACK, we can run simple models like MobileNet more efficiently than the existing reference operation implementations. with little effort. This would be a big plus to the model and model inference in Chrome OS eco-system.
The Activeloop organization provides data scientists worldwide with a solution to these problems so that they can spend more time training their models and saving resources. Hub is a package that stores petabyte-scale datasets as a single numpy-like array on the cloud, so one can seamlessly access and work with it from any machine. Hub has a simple API that enables its users to obtain a lot of functionality with just a few lines of code. However, as a complete beginner, it is difficult for many to learn the nuances of a new package. Reading the documentation is something that helps, but it is not exactly a fun way of learning something new. It can become tedious and boring. This is exactly why it would be great if Hub had a package that interactively teaches the basics of hub in the CLI itself.
The TensorFlow lite team has already build an Android app using custom Java code which includes BERT question and answering, BERT Text classification and smart reply. The Aim of the project is to build an example android/IOS app for the same but using TensorFlow Lite task library.
A peer to peer messaging app where one could send messages even when there is no internet using ad hoc networks over large area.
In this project, I will be replacing ETL with STL libraries and then will port them to the synfig core. If the perfect replacement for some ETL class is not available in the STL, then I will port it as it is.
Implement a prototype version of proot with Rust language, with the most basic features.
This project aims to make a tool to use results of Betsi and anomaly detectors to generate customisable and rich analysis Reports and make interactive graphs that can be exported in multiple formats.
Thanos Querier component supports basic TLS configuration for internal gRPC communication. This works great for basic use cases but it still requires extra forward proxies to make it work for bigger deployments. It’s also hard to rotate certificates automatically and configure safe mTLS. This project aims to remove those simplifications allowing better TLS story for all Thanos metrics APIs!
Building a platform to support users and compile openwrt packages on the fly by building an executable, code ready docker image , ready to be shipped on K3S cluster.
This project aims at re-implementing the UI for Bench-routes with a user-interface that occupies lesser space and is more compact to look at. Also, it focuses a lot on improving the code design of the front-end to make it more maintainable and efficient. It also ensures that the newer implementation is modular to expand with additional components.
I am applying to work on Ruma's automated checks issue https://github.com/ruma/ruma/issues/221 to build a special-purpose tool to check code style rules and formatting specific to Ruma. I will use rust-analyzer's syntax crate to parse Rust files into a typed AST that is checked against rules. I plan to use this AST to be able to format code inside macros since this is a big part of Ruma. I have started a proof of concept tool ruma-check that I will complete during GSoC.
The Charmil Framework will help in resolving the problems in apache Kafka examples and improve Apache Kafka CLI experience by providing a number of popular Kafka CLI’s as one single HOST CLI with others installable as plugins.
The user will import charmil in their CLI, which will provide them all the extensions out of the box. The user will be able to install specific plugins with the install command. After installing the extension, users will be able to use the features of that plugin without writing code for that particular feature which that plugin provides.
A GitHub repo will be used as the index server for all plugins. The repository will hold a directory of JSON / YAML files. Each describes a single plugin. This directory is called Plugin Manifest.
This project involves implementation of various anti-spoofing techniques in GNSS-SDR. These techniques include consistency checks to verify and validate received GNSS signals to detect ongoing spoofing attacks.
Simplifying uBlas::matrix and uBlas::vector templates using the new uBlas tensor extension as base implementation.
CGAL’s Axis-Aligned Bounding Box Tree is an acceleration structure which speeds up common tasks such as collision-detection. It is used both directly and throughout other packages in the library, so any performance improvements made to this package will pay dividends elsewhere. The package has already been a major target of performance optimization, but one approach that hasn’t yet been fully explored is the use of SIMD, a type of parallel computation where the processor operates on several data values at a time. The introduction of SIMD optimizations to the AABB tree has the potential to substantially improve performance by better taking advantage of the capabilities of modern computer processors.
I'd like to continue my work on the Director engine from last summer, improving the engine so that it is production ready for some Director 2-4 games, as well as extending it to support Director 5 and higher.
Again, my focus will likely be on Lingo, as well as implementing code to load and play Director 5 movies, and implementing major, missing non-Lingo features such as digital video cast members.
Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework, used in many particle physics data analysis and applications. Currently, we are developing a fast inference system in TMVA that takes the ONNX model as input and produces compilation-ready standalone C++ scripts as output. These scripts will then provide users an easy way to deploy their deep learning models in their physics software and analysis frameworks.
The Data Retriever is a package manager for publicly accessible data. The Data retriever automatically finds, downloads, and pre-processes publicly available datasets and it stores these datasets in a ready-to-analyze state. A number of data providers require the use of an account with an associated Login or API key to access data programmatically. The Data Retriever currently has support for the Kaggle API allowing users to securely use the Data Retriever to install datasets hosted by Kaggle. The goal of this project is to find sources of public Data which require a Login/API key to access the data and integrate them into Data Retriever. Two data sources with Python API (Socrata & CKAN) have been thoroughly researched and are ready to be added. The users will place the appropriate credentials in a file in their home directory. The Data Retriever will automatically identify the required credential files and handle the login/API request to download the dataset.
The procedure for lexical selection training is a bit messy, with various scripts involved that require lots of manual tweaking, and many third party tools to be installed. The goal of this task is to make the training procedure as streamlined and user-friendly as possible
libsecret's, "file database uses an encryption key derived from user's login password. That is not ideal because the entire security relies on the login password and is not able to cope with alternative login methods, such as fingerprint readers. The situation could be improved if the key is protected by hardware, such as TPM2 on consumer notebooks. As TPM2 has a mechanism to securely import/export private keys in a wrapped form (i.e. encrypted), the libsecret implementation merely needs to record the wrapped key as an opaque key handle along with the encrypted database upon writing, and upon reading it can ask TPM2 to decrypt the session key from the key handle. The TPM2 Software Stack provides the necessary functions for that" (Daiki Ueno, n.d.).
References:
Daiki Ueno (n.d.). libsecret: extend file backend to use TPM2 derived encryption keys. Retrieved from https://gitlab.gnome.org/Teams/Engagement/gsoc-2021/-/issues/13
Email is one of the longest standing communication methods since the beginning of the internet and is still widely used and almost every internet user has an email address. One of the core ideas of Matrix is interoperability. Having the option to communicate with everyone without having to worry if the other person is also on the same platform as you are is a major concern while switching to another communication platform.
The entry barrier to the Matrix ecosystem is lower as compared to similar projects due to the support of bridges. IRC, Telegram, Slack, Signal and Gitter bridges, to name a few, have reduced the barrier very much. By bringing email support to the ecosystem, we will be able to push the barrier to almost nil. Imagine the matrix system which will be able to communicate with virtually everyone that has a personal internet address!, i.e, the email ID.
According to an estimation, over 15% or one billion people of the total world population experience significant disabilities. These disabilities can be major or minor but the barriers in social and economic sectors for such people are the same. Even in the field of technology, people with disabilities are usually ignored. They find it tough to use websites and mobile applications. Considering such people a part of society and to make the live chat widget accessible to such people, I will implement a user-accessible mode. This accessible mode will help them to use the exciting features of the live chat widget.
The project aims to introduce Developer Options to oppia-android. There are many instances when a developer needs to make some database related changes. Doing this manually will take up lot of time and effort. Having such an option as this one will prove handy to perform these tasks without much effort and time. It allows the developers to have access to other debug related features such as viewing analytic event logs and forcing the network state of the app which will also prove useful. In short, this project aims to make the lives of developers in the Oppia team a bit easier.
This project would involve developing tools for teaching STEM through p5.js, adding functions to animate shapes, and animating maths symbols. The main focus is to introduce a simple, easy-to-use library to animate repetitive methods. It would provide educators tools to make interactive animated sketches that can support learning in the remote environment. It will take advantage of the p5.js core library - p5.sound.js for sound effects and KaTeX for rendering symbols.
AsyncAPI aims to set an industry standard for messaging APIs by providing a set of tools and features to improve the current state of Event-Driven Architecture in the world of APIs so that it can be referred to as a single source of truth.
This project idea aims to develop a library that focuses on finding and analyzing the relationships between AsyncAPI Documents to get information about Applications described by those files. It would be extendable in a way such that one can provide an additional plugin to the library to obtain output formats other than the default one.
vcf2fhir is a utility to convert VCF files into HL7 FHIR format for genomics-EHR integration. The utility currently converts simple variants (SNVs, MNVs, Indels), along with zygosity and phase relationships, for autosomes, sex chromosomes, and mitochondrial DNA. This project aims to enhance the utility by adding capabilities for the conversion of structural variants (e.g. insertions, deletions, copy number variants).
Neural AutoRegressive Flows are one of the most recent addition to the family of autoregressive flows. By using NAFs, probability density estimation in the domain of scientific exploration can yield amazing results. For example if the background data of a particular device is modelled using NAFs, it can lead to the discovery of new phenomena with very little supervision. Main goals of the project include creating basic reusable building blocks for NAFs, implementing NAFs on the given High Energy Physics data obtained from various experimentation devices, hyperparameter tuning of the NAF model for optimum performance, providing API for training plus inference and finally documenting the API and various components of the system. Final product obtained will not only be easy to use but also easy to extend.
The main goal behind this project is to create a Rocket.Chat app that adds the support of transcribing previously sent audio messages on demand, and new audio messages sent with the transcription selected.
The goal of this coding project is to develop a new R package, named 'cleanTS'. The expected tasks for this project are as follows:
Building a cross platform (Android/iOS) chat application which utilises Bluetooth and WiFi-Direct for communication, thus eliminating the need of a central server. The messages will be transferred using an optimal path which can be determined by underlying network protocols and/or GPS positioning. In particular the gossip protocol is used to relay messages through intermediate devices until it reaches its required destination.
Dark matter is one of the biggest questions in current cosmology, and many different theories were created to try to explain it. One of the challenges of studying dark matter is actually finding it, as it is only noticeable due to gravitational interactions. Fortunately, recent results have shown that strong gravitational lensing can be used as a probe for studying dark matter’s substructure. Unsupervised learning algorithms are particularly interesting in this field because they allow for the identification of dark matter substructure without a prior theoretical model assumption. While the performance of these algorithms is very promising, there is still a large gap when compared to supervised learning algorithms. One promising possibility is to use domain adaptation techniques to fine tune the models trained on simulation data with real data. Thus, this project will focus on using domain adaptation to account for the differences in the modelling and available real observation data, while also improving the interface with PyAutoLens, the software used for creating the strong lens simulations.
This project aims to add support of Go-Style Channels to the Chapel language. In Go, a channel is used to synchronize and communicate between different goroutines. A similar library can be added to chapel to support efficient communication between various chapel tasks in a lock-free manner. The channels would enable a user to decompose algorithms into tasks in a more logical way. The work will involve studying the performance against the original Go channels.
The projects aim at extending Coala's support to newer versions of Python. The lack of support for more recent versions has significantly stalled its development. The project will mainly focus on the following:
Hence, a Coala with complete Python support will be derived.
This project aims to bring post-training integer quantization to OpenCV’s DNN module and perform inference using 8-bit integer inputs and fixed-point arithmetic. Using a simple quantize() function, any Net object can be quantized, resulting in roughly 1.5x faster inference, 4x reduction in memory consumption and accuracies close to floating-point inference.
360° video is getting popular during the past years and it is predicted to evolve [1]. Compared to virtual and augmented reality, 360° video is much more accessible for viewers. The cameras are getting cheaper, and many video sharing services have an option for 360° video support (YouTube, Vimeo, Facebook) as well as applications (e.g. VLC).
360 video requires special transformations to be viewed: the most popular way to store the data at ERP and CMP projections.
The goal of the project is to implement and optimize ERP and CMP conversion algorithms using GLES. The algorithm will perform 360° video transformations between ERP and CMP. [1] https://images.app.goo.gl/iVyk3qkdxmR7CNGA8
The EOS User Story project aims at providing a user-friendly and interactive platform for users to sign in and request new icons & report bugs for EOS Icons. Also users can track the progress of their issues and vote & comment on issues that are of interest to them. The admins can then review, resolve, close or assign a status to the issues. It serves as an efficient feedback mechanism for organisations, which is necessary for the development of different products. Hence, it is a reusable project for EOS that can be used by any other organisations as well.
In this project I aim to improve EOS User Story by adding some essential features and expanding the test coverage of the project. I will also be working on fixing some existing issues in the application. The features that I will be adding as part of the project include:
For expanding the test coverage I will be using Jest for unit/integration tests and Cypress for end-to-end tests, which can then be deployed to Gitlab CI/CD pipelines and thus will help catch bugs (if any) before a PR is merged.
My most favorite thing about Oppia is its Test-Driven-Environment. All these tests (FE, BE, E2E, Lint) will ensure that no new error or bug will be introduced into the system. Since Oppia is one of the most prominent open-source organizations, it needs rigorous testing and 100% coverage.
Oppia’s frontend codebase can be broadly classified into four main categories.
1.Components
2.DIrectives
3.Services
4.Others
We have a total of 205 components. In which, 163 components have 100% coverage. Partially covered components are 42. And finally, uncovered files are 0.
We have a total of 203 directives. In which, 15 directives have 100% coverage. Partially covered directives are 188. And finally, uncovered files are 1.
We have a total of 333 services. In which, 262 services have 100% coverage. Partially covered services are 71. And finally, uncovered files are 0.
By excluding others category, we should thoroughly test and should achieve 100% coverage in components, directives, and service.
My primary focus for this project is only unit testing. Although I'll be doing angular migration as an optional entity.
Project "Metrics and monitoring" aims to collect more effective metrics which can characterize the current status of pgagroal's pool, connections, clients, servers and internal state. These metrics can be illustrated by one or more Grafana dashboards to show clearly what DBA desires to know about pgagroal itself and PostgreSQL.
RADIS is a fast line-by-line code for synthesizing and fitting infrared absorption and emission spectra such as encountered in laboratory plasmas or exoplanet atmospheres. It uses a line-by-line approach, where each absorption or emission line of a molecule is computed by accounting for the influence of environmental parameters. Even though the current implementation can compute high-temperature spectra of millions of lines in just a few seconds it is quite memory hungry. In order to be able to run computations on high-temperature infrared spectra from databases of tens of millions of lines, it is essential to optimize memory consumption in a way that it is possible for us to run reasonably large data on a regular machine (one that has 8 - 16 GB of RAM). RADIS uses Pandas dataframe for handling all the databases currently. Pandas rule of thumb: have 5 to 10 times as much RAM as the size of the dataset. Which makes it impossible to read say a database of size 5GB on a machine with a RAM of 16GB. The goal of this project would be to reduce the memory usage of the current calculations, which would make it possible to compute spectral databases of up to billions of lines.
This project uses computer vision, satellite imaging (Google Earth), and Analyze Boston to build a lightweight web service API that provides data on the solar energy potential of building roofs throughout the city. Additionally, the application presents to the user their environmental impact and energy savings by switching to solar, and, if they so choose to switch, there are clear call-to-actions to schedule the best Boston solar company for them or to schedule a call with someone who will guide them down the process.
The main objective of this project is to develop a tool for companies or competent authorities to help them visualize certain crop illnesses on the terrain, displaying photographs and locations of plants’ leaves, fruits or trunks on a Liquid Galaxy system. The tool will be developed as an Android app designed for tablets, able to control what is being displayed on the system. The problem that has inspired this project is the fire blight, although other kinds of illnesses can also be displayed.
This project aims to add improvements in the admin panel of openPIP that is used to upload data and files, post announcements and change global settings of installed instances. The project also requires work on the creation of an installation package and installation guide for the new users to follow. Ultimately, the project will prepare openPIP for publication.
My project aims to write autopkgtests for Debian Med packages, fix existing tests that fail and find and fix the errors uncovered by these tests.
PGWEB is the official repository containing the code of the website at https://www.postgresql.org/ The website code is written in Python using the Django framework. However, this infrastructure lacks a testing suite to check for the correct functioning of the website. This project aims to integrate a complete testing suite into the current CI/CD pipeline, including unit tests to test for the view, models, forms, and links, integration tests, functional tests for cross-browser compatibility testing, performance testing, and accessibility testing.
Experiments conducted at the Large Hadron Collider (LHC) are the source of the most important discoveries in new physics. One of the most prominent experiments is the Compact Solenoid (CMS), whose results rely on the reconstruction and detection of particles, jets, and topologies from low-level detector data using an End-to-End Deep Learning (E2E) model. This project intends to investigate the use of multiple Deep Learning architectures to learn the properties of simulated top quark pair events and successfully integrate the best performing architecture into the E2E CMSSW prototype.
In Krita, performing boolean operations on vector shapes leads to a large number of unnecessary nodes. This happens because Qt lacks a proper algorithm to find the intersection point of two Bezier curves. I plan on implementing a numerically stable as well as efficient algorithm to find the intersections of two Bezier curves.
The thought experiments by Valentino Braitenberg that lead to the creation of Braitenberg Vehicles (BVs) help us in very robust modeling of basic emotions emerging from simple neuronal wiring. These emotional responses can be utilized in modeling predator-prey behavior in an ecological setup. Here I propose simulating vervet monkeys' behavioral aspects (Cercopithecus aethiops), especially how they deal with predators in an ecological setting. Vervet monkeys give acoustically different alarm calls to different predators and hence show signs of semantic communication. I will use my already developed agent-based BV simulation platform in developing this simulation, primarily focusing on the communication aspects in vervets.
MediaPipe fills the gap of handling the implementation of models for different systems and allows the developers to focus more on experimentation than on system architectures. WebAssembly has become prominent in recent years as it can port C++ applications onto web browsers, making code more portable and utilizing the efficiencies of C++. In my GSoC internship, I will combine MediaPipe and WebAssembly by building an open-source realtime web video effects app. I will create a complete workflow of wrapping models in MediaPipe to be used in a webapp for running different ML-based video effects live in the browser using WebAssembly. The workflow will include wrapping the model binaries in calculators, create calculator graphs to use the model binaries, set up Bazel for WebAssembly compilation, write Emscripten bindings to access the models, and create a Typescript webapp to demonstrate how to access the WebAssembly binaries in realtime. I have extensive experience in C++ development, along with web development using Javascript. I have also been using MediaPipe for almost a year and am accustomed to the codebase. Hence, I am confident that I will be successful in my internship.
Asterix currently requires a static range hint in the query when performing interval joins. The range hint supplies split points for input data, then data is partitioned and sent to separate nodes based on those split points. A static query hint is nice because it gives the user more control over the split points and data partitioning, but it would be nice to have the option to run a query without having to process the data and its split points in advance. Within the last year, code was added to Asterix that implemented a spatial join with a dynamic range hint. This code can pick split points (or tiles) before the join. For my project, I am going to take that code, learn how it works, and then refactor and write code to make it work with interval data and interval joins.
PoorMan's Rekognition is a unique tool that provides all of amazon Rekognition's Services but with the power of open-source. Its key features include facial analysis, NSFW content detection, OCR module, scene detection both for videos and images. This GSoC proposal builds upon the previous year's work to finally make its services accessible to whomever it may concern.
This year our aim is to fix whatever is broken, improve performance of models, adding new features like image captioning, and finally deploying the project.
This project serves as a modification to the Project “Porting MAVROS for ROS2” and instead aims to provide Ardupilot with native support for ROS2 with basic publish-subscribe features.
The protocol that would be followed to implement the native features would be the XRCE-DDS protocol (DDS for resource-constrained environments). This project would involve the building of an XRCE-DDS client along with necessary IDL files for publishing time-critical vehicle messages across to either an :
This proposal will add griddap functionality to the erddapy package and simplify the API. Support for griddap will enable near real time access to gridded datasets such as climate models and weather forecasts via a simple Python API. This access will benefit oceanographers, search and rescue teams and the maritime industry at large. Additional tasks include enabling high level, simplified queries for easy access and improving the gliderpy package to make swathes of high resolution ocean glider data more readily available.
Firmware as the name suggests is a bridge between User and hardware/features of Axiom Remote. Hence, there is a need for Firmware to follow good UI/UX principles,at the same time should not be heavy on the CPU.
AXIOM-Remote General UI guidelines clearly mentions how things flow in AXIOM-Remote firmware, and the correct structure and plan one should keep in mind. I tend to follow the structure and at the point of dilemma or turmoil would discuss with mentors.
VLC is the most widely used media-player. It supports wide-range of media formats, both audio and video. For macOS, the UI is outdated, and needs a bit of redesign. This project aims to modernize VLC’s UI and give it a similar feel to the UI on iOS/tvOS.
Open Geometry Viewer is a web-based application to view 3D CAD models on browsers. Users are able to host the model online and comment on others models. I'll fix some bugs, do some enhancements and add some new features to the existing application. My take is to improve the end user's experience with the whole application. Along with that, I'll do some code quality improvements that will help other developers to maintain and drive the code easily in the future.
PyZombies proposed a web application to present all the content of the course, theory, and practical exercises, following the syllabus of Python para Zumbies. This web application intends to be an interactive book, in which the student can be able to run the exercise and get feedback about it.
The aim of the project is to increase the number of active installs in XWiki by providing the end-users with the flexibility to use Cloud Computing or services provided by AWS. There are two types of installations currently present for XWiki - Testing one and Production one. Also, there are two major versions available currently: 12.10.5 - the stable release and 13.2 - the active latest release. Cloud computing has gained significant recognition in the past few years due to the availability of a virtually unlimited number of servers and unlimited power/memory availability within seconds while maintaining a pay-per-use model for billing. As companies and users move to Cloud-based solutions for their server needs, it makes sense that XWiki too should integrate seamlessly with major cloud provider solutions. Currently, Amazon’s AWS has the greatest market share in the Cloud Market, which is greater than the combined market share of Google (GCP) and Microsoft (Azure). Therefore we need to provide AMIs and Cloudformation Templates (in the context of AWS), which end users can consume directly to spin up XWiki within minutes and start testing/working.
This project aims to revamp the Recent topic view with the addition of Multiselect Dropdown List Widget within Zulip frontend and to enhance it by providing better
control over recent feed, allowing them to filter by topic unread count and stream unread counts.
This is an essential feature for users within large organizations assisting users to read only specific topics they are interested in and sort by unread topics that they are not caught up with.
The proposal also takes into consideration of reusing specific widgets across various areas (most likey, Settings and Message edit) which can potentially enhance the UI and minimize the user's effort in achieving the desired task.
This project is about visualizing Stellarium in a liquid galaxy setup. I have divided this project into two tasks.
task-1: Setting of view-matrix offset for slaves according to their positions with respect to the master.
task-2: I have identified 16 data parameters which should be shared among cluster in real-time via socket connection.
Each of these tasks is explained in detail in the proposal.
This project proposes to implement a thread pool inside perf, which could be used first to improve the existing parallelization in the synthetic threads and then to parallelize perf-report. Furthermore, the thread pool could be reused in future work in perf to efficiently implement new parallel portions.
This project aims to develop a potential frontend for Niffler. Niffler is currently a command-line tool where the user has to download it in their system and run python commands to retrieve the DICOM images. The main aim of Niffler is to retrieve DICOM images from multiple PACS and store them as png images or metadata files. This can be done currently via the command line. Enhancing this with a frontend and making this a web application would be beneficial and easy to use by a large number of non-technical users and clients.
Financial Organizations using Mifos/Fineract are depending on external agencies or their past experiences for evaluating credit scoring and identification of potential NPAs. Though information from external agencies is required, financial organizations can have an internal scorecard for evaluating loans so that preventive/proactive actions can be done along with external agencies reports. In industry, organizations are using rule based, Statistical and Machine learning methods for credit scoring, predicting potential NPAs, fraud detection and other activities. This project aims to implement a scorecard based on statistical and ML methods for credit scoring and identification of potential NPAs.
Tensorflow GUI will help everyone from beginners to professionals in their day to day work. People who are new to the field of deep learning can use this to build , train and test neural networks without requiring in depth programming knowledge or tensorflow framework. Professionals can use it to create boilerplate code , train and test their models.
During checkpointing and restoring, CRIU locks the network to make sure no TCP packets are accepted by the network stack during the time the process is checkpointed (to avoid the kernel from sending a RST packet). Currently CRIU calls out to iptables-restore to create and delete the corresponding iptables rules. Another approach which avoids calling out to the external binary iptables-restore would be to directly inject eBPF rules. There have been reports from users that iptables-restore fails in some way and eBPF could avoid this external dependency.
This project aims to introduce support for displaying the Copyright Licenses of the third-party Maven dependencies used to build the Oppia-Android application. The implementation involves compiling the list of Maven Dependencies via Bazel query (as the Oppia-android will completely get rid of Gradle soon) and then extract the Copyright Licenses of the Maven Dependencies and then display the License texts in the actual UI of the app.
The TripPy architecture brings transformer models to Goal-oriented Chatbots. While setting new SoTA results on MultiWOZ among others, TripPy also simplifies the previous standard architecture. A better + simpler solution is what we strive for in all fields. This project implements TripPy in DeepPavlov to allow anybody to build fully functional Dialog Bots on top of TripPy leveraging the DeepPavlov ecosystem. Further, the project includes a simple demo in the form of a WeatherBot as well as a more complex chatbot demo built on the new model in DeepPavlov.
Cssselect currently parses CSS3 Selectors and translates them to XPath 1.0 expressions. The project is to expand supported features to CSS4 Selectors.
FOSSology frontend is built using the Symfony framework of PHP. FOSSology needs to be updated with new generation design and color, giving it the power of JavaScript and Bootstrap. It lacks the features and optimizations provided by the other new frameworks/libraries. For this project, I propose to Migrate Fossology UI into the React library, making it faster for development and more adaptive to newer technologies. During the GSoC period, I would rewrite the UI in React from scratch while ensuring a highly scalable, flexible, and easy to use and maintain code architecture. Also, I will be upgrading the existing API and would integrate it with the new frontend code.
I’d like to create a web-based simulator for scheduler behaviour. With web UI, users can...
SunPy allows visualization of spatially-aware data by means of Map objects. These objects have extensive 2D visualization capabilities for plotting various coordinate objects. This project primarily focuses on extending these various plotting and visualization capabilities of SunPy's Map objects into 3D by the use of PyVista, a 3D plotting interface for the Visualization Tool Kit (VTK). The project also focuses on writing extensive documentation and testing the functionality of the code along with the integration of plotting magnetic field lines from PfssPy as well.
There are several matrix implementations in Pharo. This project aims to compare all those implementations on different parameters like run-time, space efficiency, and features supported. Then, the project also aims to recommend an implementation that should be used for most use-cases or suggests writing a new implementation from scratch. The project will also explore popular matrix implementation in other languages like the Julia Linear Algebra and R matrix to find the missing functionalities in Pharo implementations.
Implementing a neural network with transfer learning for a new component of object detection in LearnBlock
Improvements to the corobo project enhancing its security, features and usability of coala’s devops bot.
With a surge of machine learning, especially the neural network model which needs to compute a huge amount of gradients, more and more languages' users begin to call for the ability to do high-performance and convenient automatic differentiation (hereafter AD) on functions, whereupon many AD tools are developed, among which is Enzyme. Enzyme is made as a plugin of LLVM and synthesizes differentiated functions directly on optimized LLVM IR code, which provides it with advantages in efficiency and universality. From another aspect, Rust is an emerging high-performance and safe language. Many of its users are trying to bring machine learning to it, thus an high-performance and user-friendly AD tool needed. Enzyme is a good option for this demand. However, without a deep integration into Rust, Enzyme's user experience with Rust is not so good, and more importantly, it may suffer from performance reduction due to wasted Rust meta-information. These problems hamper Enzyme from being widely used in Rust. This project will tackle the aforementioned problems through integrating Enzyme into Rust and then provide high-performance differentiation in Rust.
The goal of this project is to add Moving Least Squares surface reconstruction algorithms to the point set processing component. This family of algorithms reconstruct an implicit surface from a point set by fitting and projecting each point on a primitive (plane, sphere) fitting its neighborhood. The resulting surface is a smooth approximation of the input point cloud (smoothing degree is controlled by the primitive type and neighborhood size). Depending on the used primitive, several differential properties of the surface can be estimated.
Light & Shadow is an Alice in Wonderland themed gameplay mode which involves players working as two opposing teams to secure a flag from the enemy’s base and bring it back to their home base. The problem with the current implementation of Light & Shadow is the lack of viable resources/weapons in the inventory of the player that can be used to prevent the advance of the enemy team. This makes the game a race for the flag rather than a battle for the flag which definitely sounds less interesting. This project first focuses on stabilizing the current gameplay mode by fixing certain bugs and making a few improvements to the existing gameplay mechanisms and UI. It then tackles the problem mentioned above by introducing currencies and improving the inventory a player spawns with to allow for more defensive structures to be built and additional weapons/traps to be used along with various effects to help change the pace of the game. In addition to this, the entire module which is split in two has to be merged, interaction with the external modules improved, unnecessary code removed and documentation added.
Working toward 3.0.0 release
Text in a video often conveys information that is not easily expressed otherwise. This project will implement and compare the various existing state-of-the-art scene-text-transcription models and run inference of the best model on Java using legacy Java bindings of Tensorflow.
Pocket Code already implements face and text detection, text recognition, speech recognition and speech synthesization, but these features cannot be used by users with recent Huawei phones. The goal of this project is to support HMS Machine learning and Artificial Intelligence API, where other APIs are not available. So that they too can make use of these features.
A project to integrate NumPy, the leading package for scientific computations, into PySyft, a library for answering questions with data you cannot see. This will integrate core NumPy functionalities into PySyft.
Data-driven background estimation is crucial for many scientific searches, including searches for new phenomena in experimental datasets. Neural autoregressive flows (NAF) is a deep generative model that can be used for general transformations and is therefore attractive for this application. The MLBENDER project focuses on studying how to develop such transformations that can be learned and applied to a region of interest. In this project the main aim is implementing a Neural Autoregressive Flow (NAF) model to estimate the background distribution and apply it to a representative physics analysis searching for a resonance excess over a smooth background.
This project's primary aim is to tackle high priority issues and features for the mobile app, Allowing users to be more in control of the zulip experience through their mobile devices. Currently from a user experience perspective notification functionality has a lot of potential to be improved and so I will dedicate a good part of my summer for improving this feature. A higher level feature that is in demand involves encryption of sensitive user data, both at the device level as well as at the notifications and I am expecting to work on it as well. Further I will work to provide a profile UI in parity with the web app which a user will be able to update directly from their app. Another key feature that many apps use today include deep linking which allows the app to open using web links directly on the screen the user desires. Besides other things, This will be useful especially with invite links. Lastly, and this is a much broader topic, I would dedicate my free time to work on clearing abandoned issues and just plain simple bug fixes, that will aim to keep the repository more clean.
This Project aims to make Command Palette for Godot game engine that can execute some major editor actions available in editor menus. this project helps in increasing users productivity through keyboard and helps in memorizing shortcuts.
Checkstyle needs to have new Java grammar that is based on the newest version of ANTLR, version 4. This task is very difficult but it is critical for Checkstyle as ANTLR2 library is not supported (since 2006) and is far less efficient. ANTLR2 has a bunch of syntax analysis limitations that have already been resolved in ANTLR4. Checkstyle's current Java grammar numerous ambiguous rules, and requires many embedded actions and complicated constructs within the grammar itself; my proposed implementation will allow for a modular approach to solve this problem using a grammar that is very similar to Oracle's Java Language Specifications.
Elm's de-facto standard source code formatter, elm-format is based on Elm's 0.15 compiler parsing code. Since Elm 0.19 the compilers parsing code has been rewritten to eliminate the dependency on parsec and indents for parsing and to greatly improve performance. elm-format has however diverged from the compiler to the point where integrating this rewrite is nontrivial. The end goal of this project is to integrate the performance improvements from the 0.19 compiler into elm-format.
ZAP is a great tool to detect vulnerabilities of different kinds in web applications and generate alerts accordingly. However, it currently lacks a user friendly mechanism to revalidate or retest the identified weaknesses. This project aims to address this, by implementing a retest functionality allowing users to easily retest previously raised alerts, by simply selecting them and choosing the “Retest..” option in the right-click menu. This prevents users from setting up the entire scan again, thus saving time and effort.
A multisite will feature the admin panel of the talawa project. The accessibility of the admin to create, delete, completely block, read the flag request and send emails to the organization. The accessibility of the admin to create, delete, completely block a user, read the flag request and send emails to the user. The accessibility of the admin to create and post regarding any new update in the app. The accessibility of the admin to delete any inappropriate post and comment. The chat rooms will be monitored by the admin directly to stop inappropriate messages. The timely deletion of the User and Organization with a warning message after the User or Organization is inactive for a long period. Deleting the chat rooms created for the event after the event is over. The charity and donation plugin to create a portal that will manage all the transactions and other things as well and the rate will be manipulative. An algorithm to boost the ad after every count of the post will be implemented in the plugin.
TensorFlow Lite is a set of tools to help developers run TensorFlow models on mobile, embedded, and IoT devices. It enables on-device machine learning inference with low latency and small binary size. The TFLite Example Showcase allows for exploration of pre-trained TFLite models to learn how to use them in sample apps for a variety of ML applications. The new TFLite Task Library contains a set of powerful and easy-to-use task-specific libraries for app developers to create ML experiences. It provides optimized out-of-box model interfaces for popular tasks, such as image classification, question and answer, etc.
Currently, there are three NLP task examples using tediously written custom code instead of the TFLite Task Library - these tasks are for BERT Question and Answering, BERT Text classification and Smart Reply. The goal of this project will be to update these 3 existing tasks by building and testing the examples to use the TFLite Task Library instead of the previous custom code and documenting the processes with a code walkthrough - allowing developers to gain greater insight in how to use TFLite when building their iOS (Swift)/Android (Java) apps to complete these tasks.
This project is the continuation of the GSoC 2020 project OpenCV bindings for Julia. In that project, bindings for most of OpenCV’s core modules were successfully implemented. However, adoption still remains low because installing and using OpenCV from Julia is very complicated. This project aims to reduce the complexity and increase adoption by creating an easy-to-install version of the bindings and improving type conversion.
A Collision Detection system that is an alternate to Bounding Box and Precision Collision Systems. Used In Enigma to detect collisions in a game between objects and sprites.
This project idea proposes to implement two new credential bindings i.e. gitSshPrivateKey and gitUsernamePassword, that will contribute files and environment variables to sh, bat, and powershell steps so that they can use command line git to perform authenticated operations. Thus allowing Jenkins Pipeline users to run authenticated git commands in sh, bat, and powershell in a pipeline job.
Haiku has its own coding standards which describe how the code should be formatted. There is a tool for reformatting and checking if code follows these guidelines, but it has to be compiled on the developer machine and then run manually. The tool ‘ haiku-format ’ is work in progress which can be used to check the format according to guidelines which will be integrated with concourse to automate the process of checking coding style.
The goal of this project is to integrate tool with gerrit and develop the tool to give desired results, the web app Haiku uses for code reviews. It could then give quick feedback on the coding style as soon as a patch is submitted, making the review process smoother and easier.
cert-manager is a Kubernetes add-on used extensively to automate the management and issuance of certificates from various issuers.
This project aims to capture the problems users often run into when deploying cert-manager on managed Kubernetes solutions on different clouds with the help of improved e2e testing.
Gordf supports writing rdf triples to rdf file. Proposal is to create an interface that would take in a SPDX document and generate RDF triples out of it. Which will then be consumed by the gordf to generate a RDF/xml file.
Implement and improve several accessibility functions in Joomla! Keyboard navigation. Web accessibility means designing and developing your website so that people with disabilities can perceive, understand, navigate, and interact with, and contribute to the Web. Occasionally, the dispute over the definition of accessibility is revived. In fact, there are no contradictions between the two approaches. Design that recognizes the needs of all people also serves people with disabilities. Designing, for people with disabilities, brings benefits to all people - also people without disabilities. However, the term "accessibility" was defined to draw the attention of designers, not just web designers, to the specific needs of people with disabilities. W3C set up a Web Accessibility Initiative whose mission is to ensure that the web is accessible to people with disabilities including auditory, cognitive, neurological, physical, speech, and visual disabilities.
The project is about providing Ignition Gazebo with features of datasets generation to improve deep learning models training by implementing varies sensors such as labels camera & bounding box camera sensors, Also providing APIs to generate datasets rapidly from scenes.
The current print management tools only list the local queues and we have to use the web interface to work on queues shared with remote print servers individually. Since all these remote printers/scanners are IPP services, therefore we can instead display them all together including all the native hardware and printer applications along with it’s shared CUPS queues. This will provide the users who are not that well aware of web interfaces for network services a more comfortable GUI experience on a tool available in gnome-control-center. This will make navigating to the management interface of an IPP service a simple click through process for the user. This tool can also stretch it’s utility to become a general network service management tool for listing other non-printing DNS-SD services and provide easy navigation to their web interfaces.
Aerospaces sats
Enhance the functionalities in Python Honeypot Web Interface such as redesigning graphs, adding more graphs for better analysis, adding more export options, adding dark mode to the application, adding i18n for better support to users worldwide, integrating Grafana dashboard with the application, improving performance and many more.
The goal of this project is twofold: first, we wish to implement the graded ring of quasimodular forms and, second, we wish to implement the Bloch-Okounkov bracket that, given a shifted symmetric polynomial, produces a quasimodular forms.
After the introduction of SPDX Specifications v2.2 JSON, YAML, and a development version of XML had been added as supported file formats. However , the tools-golang packages currently does not have the support to parse the SPDX files nor has the support to save a SPDX document in JSON format .
The main objective of this project is to add support in the tools-golang package so that it can parse as well as save SPDX® v2.2 files in JSON format .
To add JSON support to the tools-golang package the project will make use of the official go JSON package . The SPDX specification has a JSON schema defined for the specification and has also provided a sample spdx document in JSON example format . The Project mainly comprises the JSON loader and the JSON saver . The former converts JSON to SPDX Document struct while the later generates JSON from SPDX Document struct .
The goal of the project is to develop a low-cost DIY robot kit, including the designs, tutorials and use-case scenarios. The DIY robot kit should be 3d-printed, assembled and operated using basic electronics and sensors.
Git has historically had many components implemented in the form of shell scripts. This was less than ideal for several reasons:
The goal of this project is to complete the conversion of the remaining parts of git submodule to C, namely, the add and update commands. If possible, I intend to even get rid of the shell script called git-submodule.sh entirely, which currently calls submodule--helper to perform most of the business logic, and instead make submodule a proper builtin in pure C.
In this project, We’ll create an HTTP library that uses cronet (Chromium’s network stack) under the hood providing better performance, access to modern features (like - QUIC) and being great at handling network uncertainty which is an everyday scenario for mobile apps.
TensorFlow’s Model Garden and TensorFlow Hub contain the most comprehensive and easy to use model implementation for SOTA models. These implementations need to be lightweight and pretrained to SOTA numbers. They also need to be compatible with all Keras layers and operations. Recently, two of the arguably most fundamental models received an upgrade, namely ResNet-RS and EfficientNetV2. This project aims to implement these models and incorporate them in TensorFlow Hub and TensorFlow Model Garden. Moreover, I intend to make tutorials and solve issues related to the same and beyond.
In this project we are trying to provide a High-level API for the Deep Learning engineers and researchers to help them train their models faster, and provide them many other various features:
Property Wrappers are responsible for wrapping common getting and setting boilerplate and also for storing any auxiliary helpers. Often, these helpers are the same across different instances of the wrapper. Thus, having to store it in each individual wrapper instance is a waste that should be avoided. We can solve this by introducing a static storage that is shared across instances, within the scope of where they are declared. Thus, providing a tool for property wrapper authors to optimize their wrapper abstractions.
@propertyWrapper(shared: Storage)
struct Clamped {
private var value: Value
struct Storage {
let range: ClosedRange<Value>
init(_ range: ClosedRange<Value>) { // ... }
}
// wrappedValue would be accessed through a subscript
subscript(shared storage: Storage) -> Value {
get { value }
set { value = storage.range.clamping(newValue) }
}
}
The goal of this project is to provide typed API for LuaRocks modules, specified using Teal, a typed dialect of Lua, which allows for typed definition files to be written for untyped Lua modules. Our goal here is not to port all of LuaRocks to Teal, but to provide typed interfaces for Teal or Lua applications, so that users of these interfaces can have a stable contract of the API's inputs and outputs.
CGAL currently supports the decimation of triangular meshes using two distinct strategies: Lindstrom-Turk and Garland-Heckbert. These strategies assign a cost to each edge collapse so that edges can be iteratively collapsed in order of least cost until a condition is met.
Our focus is on the latter of the two strategies, which uses quadrics at each vertex to calculate a cost. The paper Fast and Robust QEF Minimization using Probabilistic Quadrics explores the use of probabilistic - as opposed to classic - quadrics and shows that in many use cases, including but not limited to mesh decimation, probabilistic quadrics give better results, are more robust and about as efficient as classical quadrics.
The aim of this project is to introduce support for probabilistic quadrics in the context of mesh decimation in CGAL, which would improve the library's capability to quickly generate highly desirable mesh simplifications.
The main objective of the project is to build a consistent API leveraging MNE-Python to perform connectivity analysis of neural time-series data, such as MEG, EEG and iEEG. The result would be “mne-connectivity” a Python3.6+ software package that allows scientists to explore connectivity based analysis using published algorithms with few barriers because it leverages the widely used open-source platform of MNE-Python.
Create a new engine to support Faery Tale Adventure II: Halls of the Dead by The Dreamers Guild.
The Wikipedia Preview acts as a medium that provides Wikipedia content in the form of contextual information to be available on 3rd party sites. It consists of showing information from Wikipedia projects that involves images, definitions or reading more content related to an article directly from the provider’s website. It helps users to gain contextual details from Wikipedia without actually visiting it. Whenever a reader hovers over a link to an article, a short summary of the subject and an image (if available) will be displayed.
The goal of the project is to enhance the working of Wikipedia-Preview by testing the preview against test cases. This involves writing a quality level of tests that checks the preview on different parameters. This will help in identifying the fallback conditions and help in delivering better Preview to the end users.
The project involves writing cypress tests for Wikipedia-Preview. Cypress provides a better interface for writing, running and debugging standard test cases for the projects developed in javascripts.
A Swift BitArray that stores 8 times more data in the same amount of memory! Primarily, the BitArray is an array of Booleans (like Array<Bool>) Each Boolean stored in the Array<Bool> takes up one byte of memory, as a variable cannot be any smaller, but a Boolean only needs one bit to differentiate between true and false. Hence, for every element added to an Array<Bool>, 7 bits of memory are technically wasted.
A BitArray optimizes this by making use of each bit by storing the values into a UInt8, with each bit of the binary number of the UInt8 representing a Boolean value (1 for true and 0 for false). It would make use of clever bit operations for storing, retrieving, changing, and removing values.
The API can be implemented as an array of 1-bit "Booleans" or an array of small integers which hold the indices of the true values. Either way, the memory used is far less, and both API implementations allow for different benefits. The ideal would be to implement both, with one being the primary API.
Extracting metadata from AV1 videos is very useful for codec research. They can be used to create a video analyzer, analyze coding performance of a video, encoder development and many other purposes. While there is a way to extract metadata by using the reference decoder, libaom, the process is slow and extraction of sophisticated metadata is lacking. The goal is to create a lightweight rapid metadata extraction tool which extracts all the relevant metadata from the decoder end for research and development of AV1 tools. The aim for this project is to use dav1d, a fast decoder, to extract metadata similar to how libaom extracts metadata and build up further by extracting more information such as residual data, performance data, add more compression options for JSON and grant the ability to store in binary.
This project aims to implement Automated Visual Regression Testing alongside the current testing infrastructure to ensure robust testing coverage.
My proposal is about improving the robustness of MifosX and Apache Fineract by fixing issues/feature requests from the backlog. There're currently 5 issues attached to this idea. Some of them contain UI improvements as well as the server side implementations. Also I'm willing to take up the "Collateral Module" feature request which will be linked with this idea. I've written my ideas on each and every issue linked with this in a detailed manner.
My goal for Google Summer of Code is to make OONI better at measuring TLS and QUIC blocking. OONI develops the open source software OONI Probe which provides tools for measuring internet censorship. QUIC is an emerging transport protocol that was initially designed by Google to solve problems with the existing TCP/TLS architecture. With increasing traffic volumes, it is significant to observe and measure QUIC blocking.
I want to identify and resolve existing inconsistencies with the QUIC code that I have contributed earlier this year.
Eventually, the QUIC code should get to a point where it can be used in production by the Desktop client. Therefore, the first deliverable of my GSoC project will be to integrate QUIC support into the OONI Web Connectivity experiment.
The second part of my project will be to implement the capability to parrot the TLS fingerprints of popular web browsers. TLS fingerprinting is a censorship method which identifies browsers based on the structure of the TLS ClientHello message. The ability of parroting TLS fingerprints will enable OONI Probe to measure and circumvent TLS fingerprinting.
100 Paper Cuts aims for improving user interface, implementing enhancement requests and solving most-annoying issues on the UX side of LibreOffice.
Sample Platform is CCExtractor’s platform to manage tests, upload samples, run regression tests and much more. The main purpose of the platform is to test each and every pull request of the CCExtractor repository with the samples uploaded (which currently has 180GB of samples) and report status. This will ensure the pull request being merged is safe and secure.
Currently, the sample-platform runs a test using KVM instances, so it is capable of running only one test at an instant which is a major drawback. With a lot of cloud offerings available, the process of running tests can be parallelized thus making the system more efficient and powerful.
With the migration of sample platform from KVM to Google Cloud platform, long run time issue can also be resolved which happens when there are a lot of commits or pull requests opened.
The project aims to design and develop a Peer-to-Peer Messaging app that does not rely on a central server to send messages across the peers. The app is intended to provide privacy, high communication-efficiency, censorship resistance and extra resilience to the users.The app should be reliable and usable dependent/independent of network connectivity.
Adding support for the multiprocessor ACPI APIC HAL
Scan8 is a kubernetes based rapid URL/file scan system that allows users to submit a list of URLs/file and take out the scan results.Scan8 uses ClamAV open-source antivirus project as the scan engine and Google gvisor as the container sandboxing for k8. The overall system is able to create a large number of lightweight ClamAV containers (Pods) and distribute the scan list on demand and take out the scan result within a short amount of time.
It is common for compilers, and LLVM in particular, to transform calls to memcpy or memmove to a number of integer loads and stores of the corresponding bit width. After, load and store instructions can be optimised further. However, semantics of memcpy and memmove specify that the memory is copied as-is in bytes, and LLVM does not have a type to represent the handle to the raw memory (like unsigned char or std::byte in C/C++). This leads to incorrect transformations and miscompilations.
This project aims at introducing a new byte type to LLVM IR to fix miscompilation issues and to make the semantics of type punning in LLVM consistent.
To improve triage and tracking of reports: (A tool to append new scans to previous scan reports A combining tool to merge different reports )
To improve structure of cvedb.py (Not reinitialize the database in case of timeout or some other problem A way to download only the modified NVD files rather than initialising the whole database every time. This feature can be included for users who want to run scans very frequently .)
The most frequently used Ruby Core APIs Kernel::require and Kernel::require_relative are doing the same work: it’s to resolve the file path, read the file, compile ruby source to bytecode or load a shared object, evaluate and add an entry to $LOADED_FEATURES . But if using Ruby stdlib benchmark to profile their performance, we can figure out a fact: require a relative path is almost 10 times slower than require an absolute path and about 4 times slower than require_relative the same path. This proposal aims to figure out the reason and optimize it.
This project aims to add portable implementations for SIMD ISA extension AVX-512 functions which are not yet supported by SIMDe. This will make development with highly optimized code more universal and allow developers to write and test vectorized code for many applications even without access to specific hardware.
PcapMonkey provides an easy way to analyze .pcap using Suricata, Zeek, and Elastic SIEM. The goal of this proposal is to improve and enhance PcapMonkey to help analysts work faster. A broad list of work to be done in the project during the summer is:
irde.st is a software suite that allows users to create an internet-independent, decentralized & ad-hoc wireless mesh network. It removes all the dependencies of a user from a specific service and enables users to create a local network mesh of their own. It does not expose data or information of the user, even the IPs of the peers present in the mesh are not known they communicate via routers and the entire communication is end-to-end encrypted between the users, thereby increasing privacy in user data. As of now, Irdest supports various functionalities to users like sharing files over the network created, call between users. messaging.
This summer I plan to package and implement some of these core functionalities in an android application. The project aims at first building the FFI layer for interaction between the rust lib code and android, and then implementing the features required. The final product/deliverable of this project will be an android application that'll support the features which are provided by Irdest in the upstream.
Metatheory.jl is a general purpose metaprogramming and algebraic computation library for the Julia programming language, supporting the novel technique of e-graph term rewriting through equality saturation, first introduced in egg. Our contribution allows performing general purpose symbolic mathematics, manipulation, optimization, synthesis or analysis of syntactically valid Julia expressions and user defined types, with a clean and concise programming interface, both during compilation or execution of programs. We have been currently experimenting with optimizing mathematical code and equational theorem proving strategies. Some of the proposed tasks for this project include:
Currently the gora-sql module is outdated and only supports mysql database scheme. This module can be rewritten in JOOQ in such a way that it can support any Relationshional database store [2]. JOOQ is a widely used Java framework which helps to build applications where persistence requires and is highly regarded by industry specialists over Hibernate & JDBC [2]. Hibernate itself is very distant from normal sql queries and JDBC has security concerns and also too much hassle when it comes to transaction handling. JOOQ will be a very good addition to the Apache Gora project as it creates a path for Relational databases to work with apache gora seamlessly.
LoopSim framework aims to facilitate workflows with loops i.e workflows without specific start and end services. LoopSim requires an interface to create these types of workflows using some kind of graph.
It currently relies on a Closed Source software yEd - Graph Editor for workflow creation. The objective of this project is to remove this dependency on a closed source software and build an open-source solution tailored for LoopSim requirements.
We also need to integrate this project with the existing parser so as to automate the flow from running the script and building the workflow to parsing it. The proposed solution will make it easier to web host the LoopSim project.
Following the spirit of Everything Nodes, I think it would be better if we have a Testing Framework in place for the Geometry Nodes.
ChemTools is an open-source Python library for interpreting quantum chemistry calculations. It is currently the only library capable of interpreting those calculations using Conceptual Density Functional Theory – a framework that has matured over the last four decades, but still lacks exposure to practicing chemists.
In this project, I will contribute to ChemTools library by incorporating two popular quantum chemistry libraries – PSI4 and PySCF. This will result in a much better cross functionality and give practicing chemists a one-stop library for both performing and interpreting quantum chemistry calculations.
I am interested in giving Juice Shop’s score board some TLC (tender love and care) and making it easier for beginners to understand their progress. I wish to do this using simple UI and managing assets and information to optimize the render speed. The goal is to make progress easier to track for beginners whilst also allowing pros full visibility. My proposed contributions will include: separating challenges from progress so as not to overwhelm beginners; featuring challenges based on user’s comfort level (ie., "Try out this ⭐⭐⭐ challenge"); giving each challenge category its own progress bar and checkpoints (this can be toggled on and off and is secondary to the complete progress); some of the solved challenges could be accompanied with a "How We Solved It" instructional guide outlining solutions from Bjoern Kimminich's "Pwning OWASP Juice Shop" guide; making progress stars lead into more information (ie. click on the first ⭐ and reveal all the solved challenges from the one-star category); for fun: Request juice box icon from FontAwesome and potentially make difficulty levels juice themed (🧃 instead of ⭐) to maintain thematic consistency
This project aims to enable JavaScript visualizations in TOPPView using Qt WebEngine and its different modules.
This proposal is all about adapting Schema Editor to work with ModelState in spite of the model classes.
The first milestone is to create a central registry that could store all the relations between models.
The second milestone would be, to create method mapping in ProjectState for all Opertion subclasses' state_forwards and state_backwards. For Example CreateModel.state_forwards calls into ProjectState.add_model_ where all the logic is encapsulated. Similarly, there would be new methods in ProjectState like alter_field, rename_model and so on that would be called by the state_forwards of respective Operation subclasses.
The third milestone would be, to update SchemaEditor methods and properties along with all database_forwards and database_backwards methods in order to adapt ModelStates.
Liquid Galaxy as a meaningful presentation tool has a lot of information that can be displayed for diverse purposes like an educational tool, or for a monitoring system. With that in mind, the idea of the project is the real time visualization of satellite images that would be attached as layers of google earth, besides being able to have diverse information of the earth being graphically generated as storms, fires, masses of heat and water vapor, a synchronous earth visualization will allow for more complex interactions. From there, the entire application would be controlled through a script responsible for managing calls made to the satellite's external APIs (e.g. NASA API and Copernicus) that responses with the metadata necessary for the kml creation and a tablet application that would give the user control of which layers or information would like to be displayed and responsible for handling the API calls, manipulate KMLs and sending them to Liquid Galaxy through Bash scripts. The application’s front end will be developed with Flutter and the image selected by the user will be generated based on selected options
I propose to add OnCanvas Alignment Guides to Inkscape. When enabled, while moving objects around the selection will snap to temporary Horizontal or Vertical guide lines that will appear if the selected object can be aligned relative to another object on the canvas.
Alignment guides are Horizontal or Vertical lines that only appear when you're editing objects on the canvas. They provide more contextual information about and objects X/Y position relative to other nearby objects. As you get closer to align the selection with the edge of another nearby object, the selection will automatically snap to that position and an Alignment Guide that coincides with the (now aligned) edges will appear to indicate that a snap has indeed occurred. This guide can be in vertical or horizontal direction depending on the optimum snap found.
Addition of alignment guides will imporve UX and make the task of aligning objects relative to each other easier.
The aim is to implement a decoupled, publish-subscribe-based continuous integration (CI) and delivery (CD) solution that allows developers to notify deployments of available updates, which can then autonomously decide what to do with them. The broker would manage subscriptions for update notifications for each deployment, offers an endpoint that listens for updates, builds and publishes container images and notifies services.
ModelBricks is a tool for bioinformatics researchers that allows users to browse, view, and download detailed models of biological processes. I propose that various needed visualizations, and model retrieval functions are added using the existing code framework and the VCell API. Furthermore, I propose that the VCell API be expanded to include useful functionality such as more versatile searching and permissions changes.
Modification of current code with ES7 and JSX( JavaScript eXtension ). Improving UI by making it more user friendly.
This project is to build a dashboard that will deliver features to enable an admin handle activities. It will offer filterable Pivot Table of Activity, and also provide meachinism for the admin to select an Activity Type and date period and delete the Activities including any related data in the log tables (if used).
In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation.
ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. ROOT has a clang-based C++ interpreter Cling and integrates with Clad to enable flexible automatic differentiation facility.
TFormula is a ROOT class which bridges compiled and interpreted code.
The project aims to add second order derivative support in TFormula using clad::hessian. The PR that added support for gradients in ROOT is taken as a reference and can be accessed here.
Optionally, if time permits, this project will also convert the gradient function into CUDA device kernels.
This project aims to add enhancements to Scrapy's Feed Exporter components. These enhancements consists of item filters, feed post-processing and batch delivery triggers. Currently there are no convenient ways to filter items before they can be exported. Item filter feature will provide such ways and interface. A Feed post-processing enhancement will enable plugins such as compression, minifying, beautifier, etc. which can then be added to the Feed exporting workflow. Batch creation was a recently introduced feature but was limited to only item count constraints. Batch Deliver triggers will be able to make the constraints flexible and give more control to user to create batches.
The Idea for this project is to bring in the global timeline to ease certain types of tasks and increase productivity. This will essentially bring in a non-zoomable Timeline which will serve to ease the task of trimming, cutting, rearranging clips on the timeline in sync with the other timeline.
Fabio Gandolfi gsoc username: zwerg4 email: fab.gan@hotmail.de github: zwerg4
My name is Fabio Gandolfi, I am a 24 years old computer science student of Italy but currently living and studying in Austria.
I am very interested in programming in a lot of different programming languages. Currently I am studying Computer Science in Graz (Austria). I would propose to the iOS team where I already contributed some new features and therefore already have an overview how the app is built.
INTEREST: Pocket Code for iOS: Support for Catrobat Language version 0.994 - 0.99992. This task seems interesting to me and I would like to implement it during the summer to bring also some new compatibilities to the iOS app.
Since I already contributed to your amazing project and really liked it a lot also because I learned a lot of new things and because I think it has a lot of potential I am really looking forward to work with you also in the Google Summer of code.
Fundamental questions about Thermonuclear Supernovae (Type-Ia or SNeIa), the beacons visible across the universe, remain unanswered. Using the currently-available extensive library of detailed supernova simulation data, I aim to identify machine learning and computational techniques suitable for this project, produce a cluster-predict model that identifies cluster classes based on observable parameters, characterize the degree of confidence of the model, and ultimately establish classification metrics for Type-Ia supernovae to prepare for future nuclear astrophysics investigations, advancing our understanding of these beacons of the cosmos.
This project, based on this idea by the Pitivi team, aims to implement an easy to use feature which lets users quickly synchronise their edits - be it clips, photos, or any kind of transitions in between - with the music they put in their videos.
After the user chooses an audio track to sync the clips to, a 3rd party library like librosa will be used to detect the tempo and timing of beats there. If it succeeds, Pitivi will provide the user with points on the timeline that they can 'snap' their clips to, each one representing a beat in the chosen track. For quick and easy usage, users will also be able to just choose some pictures from their library and have Pitivi automatically sync them to the music of their choice. Advanced users, on the other side, will have the ability to change settings like beat snap divisor or manually specify the timing and tempo of their song, to ensure they get the desired results.
Update the user interface of vlc-ios to match or surpass the Android app.
Clang Static Analyzer has an in-built constraint solver which is trivial but pretty fast. The aim of this project is to introduce support for range-based logic for binary operations.
FALCON is the current state-of-the-art Multiparty Computation (MPC) Framework for Private-Deep Learning(PDL).MPC allows mutually distrusting parties to jointly compute a function without revealing their private inputs beyond what is revealed by the output of the computation. PDL allows multiple parties to collaboratively train a Machine Learning model without revealing their private inputs. It also encompasses secure prediction.MPC is one of the privacy advocates for PDL.
The project aims to implement FALCON in the SyMPC library. It would greatly improve the performance of the SyMPC library for training and inference.
Talawa App already has the English language at the moment. As the app is being targeted to a broad audience so we need to support more language for great user experience and engagement. While the current language will be reused, we will be changing its hardcoded nature in the widgets (like app bar, buttons, form fields etc) to a more dynamic one. Users will be allowed to easily switch the language of their choice during Signup or Login. Users will also have the capability to change the language inside the app. Talawa app aims to build a strong and meaningful relationship among the members of the organizations with the help of features like group chats, news feed and events. Therefore making sure of effective communication between people of different language is also necessary. Modification in the backend will be done accordingly to help different language users to communicate effectively in groups. This project idea serves to solve the barrier of communication which can hinder the growth of the community through the Talawa app.
In this project, we will attempt to embed FreeCAD into Pharo Smalltalk IDE, such that Smalltalk code can drive FreeCAD directly. With a pure object-oriented programming environment and excellent debugger that Pharo provides to the user, we aim to create a productive CAD scripting tool within the Pharo environment. This tool will have the flexibility of scripting that Smalltalk provides, and the speed of C++ to produce CAD visualisations immediately; which is very conducive in rapid-prototyping and multi-disciplinary projects.
Kolibri has a Tasks API that runs time consuming tasks asynchronously outside of HTTP request / response cycle hence unblocking the HTTP connection for other requests.
The current Tasks API backend has a very poor consumer experience. Adding new tasks require plugin developers to inherit from kolibri.core.tasks.api.BaseTaskAPIViewset class which adds in multiple extra endpoints for handling of this new task.
The current architecture makes it a tiring experience for plugin developers to submit and monitor their custom tasks. It also disturbs the core Tasks API code and has heavily polluted kolibri.core.tasks.api module.
This project fully revolutionizes the Tasks API backend.
This project aims to make it super straightforward for plugin developers to submit, monitor and manage custom asynchronous tasks with a simplified backend architecture.
The result is:
And most importantly, this makes the Tasks API super duper easy to work with.
The functioning of complex systems (i.e. the brain, and many others) depends on the interaction between different units; crucially, the resulting dynamics is different from the sum of the dynamics of the parts. In order to deepen our understanding of these systems, we need to make sense of these interdependencies. Several tools and frameworks have been developed to look at different statistical dependencies among multivariate datasets. Among these, information theory offers a powerful and versatile framework; notably, it allows detecting high-order interactions that determine the joint informational role of a group of variables.
The goal of this project is to collect and refine existing metrics of high-order interactions currently implemented in Matlab or Java, and integrate them in a unified python-based toolbox. The main deliverable of the project is a toolbox, whose inputs are the measurements of different variables plus some parameters, and whose outputs are the measures of higher-order interdependencies. Ideally, the toolbox will interface with visualisation & processing platforms of neuroimaging data, such as MNE, fMRIPrep and can become a docker container too.
In this proposed project we build JaxModel, which provides a high-level API for training and deploying Machine Learning Models using JAX framework. The main goal for JaxModel will be to provide an API for building, training, and testing deep learning models which are compatible with the existing DeepChem code base which already provides features like Molnet, Featurisers, Splitters, Transformers, and other deep learning infrastructures. During the period of GSOC, I will also be adding a notebook tutorial specifying the usage of JaxModel. If time permits, In the same tutorial I will also use an advanced JAX-based model preferably (Graph-based model or Physics Informed Neural Networks). This will be the beginning of implementing JAX-based models into the main DeepChem repo.
Adds a new List component to React Admin which implements infinite scroll to the Navidrome Data Views
The idea behind the project is to create a hydra-powered REST API that aims to serve the loan portfolio data to various consumers for regulating, valuation, and various other purposes. This project will be a prototype of "APIs for Fintech" with Hydra Ecosystem.
zfit is a highly scalable and customizable model manipulation and fitting library. Using Tensorflow as its backend, it has been optimised for simple and direct manipulation of probability density functions with usage target High energy physics analysis ecosystem. The main focus is on scalability, parallelisation and a user friendly experience framework (no cython, no C++ needed to extend). Zfit currently misses library functions which are especially useful in physics. My aim is to implement a new library function named Faddeeva function or Kramp function that can simplify the process of calculation of scaled complex complementary error function. This function arises in various physical problems, typically relating to electromagnetic responses in complicated media.The purpose of this new library function is to cater to the needs of scientists and researchers with minimal knowledge of low-level implementation of the function with high performance and accuracy.
3Dmol has most of the necessary features that make it a good visualization plugin for application and web. But this tool becomes difficult for the audience that is not familiar with web technology. Making its features inaccessible and making it harder to use as compared to similar applications like VMD, Visit, ChimeraX, PyMol etc. Hence there is a requirement of an UI that can make 3Dmol more accessible to the audience. To achieve this a layout for UI and additional controls for camera are proposed. That can expose all the features of 3Dmol. This will make 3Dmol easier to use and increase its application in general discussion, teaching and presentations.
Webiu is a “generalized website builder” which magnificently eases the essential process of getting a website up and running easily. The project provides almost all of the different sections required by a normal website as different reusable components. This project proposal aims at adding and implementing new features and functionalities into the current project to make it more reusable and accessible and further ease the process of building a website. Creating a logo, improving current components functionally, developing new components, creating an NPM package for Webiu, documenting the components using Storybook are some of the works (but not limited to) proposed. The proposal when implemented will functionally improve the current project, increase the range of the project and make the components accessible to other developers to incorporate them for developing websites.
I plan to write SIMD assembly for the new tx (transform) subsystem in FFmpeg, targeted at AArch64 for double precision inputs.
Metabolic modeling has been interwoven with constraing-based methods. The value of randomized sampling in the framework of metabolic modeling has been proved itself over the years (see Schellenberger and Pallson (2009) and Herrmann et al (2019)). Aim of this project is to integrate the produced data and knowledge of these twenty (and more) years and make use of the randomized flux sampling method to evaluate the metabolic interactions retrieved. To this end, thousands of publicly available reference microbial genomes will be selected, and their automatic metabolic network reconstructions will be implemented. Based on these models, cross-feeding interactions algorithms will be performed for groups of species to extract key metabolic processes. New functions, implementing the recently developed Multiphase Monte Carlo Sampling (MMCS) algorithm in the framework of the dingo library, will make use of the randomized flux sampling concept to evaluate the processes retrieved.
The International Image Interoperability Framework (IIIF) describes a standard to interact with images that are being adopted by an increasing number of museums, archives and other institutions that store large collections of digital images. The aim of this project is to make vitrivr compatible with the APIs specified by IIIF so that it can be used to interact with any IIIF capable data sources easily. The primary goal of this project is to allow Cineast to download files from a IIIF compliant server and extract features through these files using the extraction service.
Current limitations with the variant detection using wbtools (and entity extraction in Wormbases’s AFP pipeline) is that it relies on regular expression and string matching with database. This approach can not be scaled to the entities or variants which do not have a clear pattern or are novel - especially relevant when there’s a lack of common consensus in SNP nomenclature.
This proposal, in short, aims to increase entity detection capabilities of the AFP pipeline (and variant or strain detection capabilities of wbtools) by integrating more data models in the current pipeline, and for cases which aren’t possible to be generalized using a data model, use the present curated databases to train Named Entity Recognition (NER) using BERT to extract data from papers. Then, validate the discovered SNP by using NCBI’s Basic Local Alignment Search Tool.
Learning equality’s specific goals for this year has been to continuing to develop and improve upon key features of Kolibri App, one of the primary goals being is to build out a diverse content library and a wide array of content that caters to multiple different subject areas.
Kolibri App uses the Khan Academy Perseus framework to display assessments to learners, collect interaction data, and provide feedback, but the types of questions supported by this framework is only suitable for maths being insufficient for many other subject areas. The tool to support the creation of assessments are currently only limited to four types of questions.
A new feature, the Kolbri-Assessment Delivery System is under development for the purpose of supporting an interoperability standard called QTI (Question and Test Interoperability) that will allow us to create assessments, import and export question banks to a valid QTI xml format and expand the types of questions types that can be utilized within Kolibri for assessments (i.e. essays, drawing on a photo, etc.). This feature will try overcome the short comings of the Perseus framework, no longer being supported by Khan Academy development team.
Cert-manager can be installed using Helm or with regular Kubernetes manifests, but when using regular manifests it is difficult to customize the deployment. This CLI will make it easier for non-Helm users to customize the configuration of cert-manager, it will provide a way to see all the configuration options for a cert-manager deployment from the command line (i.e. by running kubectl cert-manager install --help). It will provide an option to wait for and verify the deployment, perhaps by integrating the code of cert-manager-verifier. And it may become the foundation of a future kubectl cert-manager upgrade command, which will help users safely upgrade and downgrade between cert-manager versions.
Robustly identify standard visual fiducials for AprilTags and their orientation. Create a general method in OpenCV of turning a sufficiently textured planar tag into a fiducial that allows for position and ID.
The goal of the project is to use ML techniques to identify relationships between planetary mapped datasets, with the goal of providing deeper understanding of planetary surfaces and to have predictive power for planetary surfaces with incomplete datasets. There are three main proposals for the stated problem:
My main goal during this project will be to improve the tooling and testing infrastructure of Zulip. Along with this, I will also work on adding useful integrations to Zulip.
This project aims to add the NATS messaging system to the current list of CEPH’s bucket notifications endpoints. Bucket notifications provide a mechanism for sending information when certain events are happening on the bucket to external systems. Adding NATS as a cloud native messaging solution will be useful as CEPH can run inside Kubernetes.
Briefly, the problem is detecting the course markers to help an autonomous vehicle find an optimal trajectory to complete the circuit. The idea is to develop an algorithm that will help a controller, which will first be demonstrated on an autonomous car that will navigate a closed course in minimal time. An embedded device(Raspberry-Pi) will be used to take live video input and run the algorithms on it.
This project aims to write frontend tests to fully cover each service, directive, and components in order to ensure that the quality of code throughout the codebase is maintained saving time for developers and providing a better, bug-free experience to the user.
A feature that will allow pasting special text into Joplin and have it converted to Markdown
This project will create a modular framework for world generation in Destination: Sol. This will allow more flexibility in the way the world can be generated. Instead of the current system which has very few options for world generation, this project will lay the foundation for a system which can support many options.
The current version of OWASP Nettacker needs some improvement in WebUI. I will make some changes to each page of the WebUI/API to make it look cleaner and cooler. My work will include changes in Basic and Advance Scan improvements in the New Scan Page. I will be changing the layout for the results and crawler page. Also, the changes will be done to the Page where individual results are shown in form of a Graph.
Developing Deluge Client using flutter and dart along with modern material interface.
This project aims at enlarging the reach and approach-ability of youngsters to circuit design through a block based approach of the TL-Verilog Language. This will further enhance the toolset of the MakerChip IDE and bring more people towards simple, concise, circuit design.
People with special-needs face a variety of different challenges and barriers that isolate them from their surroundings. Nowadays, several assistive technologies have been developed to reduce many of these barriers and simplify the communication between special-needs persons and the surrounding environment. However, few frameworks are presented to support them in the Arabic region either due to the lack of resources or the complexity of the Arabic language. The main goal of this work is to present a mobile-based framework that will help Arabic deaf people to communicate ‘on the go’ easily with virtually any one without the need of any specific devices or support from other people.
NuttX is a real time operating system which provides wide support for smaller and cheaper microcontrollers and development boards. PysimCoder is an open source Rapid Control Application Design tool which is able to transfer block diagrams into C code. Main goal of the project is to integrate and test pysimCoder support for various kinds of drivers supported by NuttX. The main target platform is iMXRT1060 MCU, but some other platforms like STM32 or RISC-V ESP32-C3 can also be considered for testing and demonstration.
Project proposal on issue#4813 about holding multiple SSH keys. As of now, ACS supports only a single SSH key to be added / reset on a VM. Here I propose a project on support of multiple SSH Keys.
Single-Cell sequencing is a new methodology that provides high-resolution data to understand individual cells. Applied to RNA sequencing, it can reveal a multitude of relevant information, such as identifying different cell types within a sample and RNA velocity to understand cell fate. The possibility to query individual cells permits a fine-grained analysis compared to conventional NGS (Next Generation Sequencing) methods.
Reactome is a “free, online, and open-source database” that stores pathway data from various organisms, such as genes that make up the pathways and hierarchy mappings. Leveraging on this curated data and using single-cell resources from descartes database, we can enhance this data by annotating which pathways each identified cluster represents.
This project aims to create a dockerized python pipeline to extract pathway activity from single-cell clusters in a systematic manner, annotating each cluster with which pathway it represents.
Buildpacks are a kind of framework for preparing a container environment for your apps. Lifecycle is a particular workload that needs to run one by one in order. A Lifecycle Prepare phase should make it easier for Platform Implementers to achieve parity with features of Pack. Today, features like project.toml are only supported by Pack, and a new platform would need to write it’s own parser. My goal is to create new Lifecycle phase and associated binary should be available to Platform Implementers, and should be executed by Pack.
The AXIOM Remote is a device used to control the AXIOM Beta range of cameras. The aim of this project is to develop an automated test system to test the various electronic components on the Axiom Remote from the AXIOM Beta.
The new frequency transformation infrastructure in libavutil is lacking 64-bit float versions of FFTs and MDCTs for x86. This projects aims at filling this gap.
In my Project, I will implement a process in PocketCode which makes it possible for users to merge already created catrobat-projects. This extension will offer new possibilities for the user, for example, he can create a joint project with other developers.
Science and technology are the key for improving social inequalities and the quality of life of citizens. That's why civic technology projects are fundamental.
This is a draft proposal about the proposal which talks about a large number of Tor users report getting hit by infinite Captcha loops when visiting some of the most popular websites, such as Reddit, Twitter or YouTube which makes them feel punished for using Tor to protect their privacy and prevents them from legitimately accessing websites.
While markers are a nifty feature of Inkscape, their usability is heavily impaired by their limited interface. Currently, a marker’s position, size, and color are all directly tied to its parent object’s properties. While Inkscape users have found clever hacks around these issues like editing marker sizes through the XML editor, the rigid marker interface hinders users from utilizing them to their full potential. The goal of this project is to revamp Inkscape’s marker feature to make it more robust and user friendly.
The project aims to develop a prototype that is capable of meaning construction using multi-modal channels of communication. Specifically, for a co-speech gestures dataset, using the annotations obtained manually coupled with the metadata obtained through algorithms, we devise a mechanism to disambiguate meaning considering the influence of all the different modalities involved in a particular frame. Since only a handful of annotated datasets have been made available by Red Hen, we leverage semi-supervised learning techniques to annotate additional unlabeled data. Furthermore, since each frame could have multiple meaning interpretations possible, we use human annotators to annotate a subset of our validation set and reportour performance on that set.
Edge Coloring is an algorithm used for coloring of the edges for the vertices in the graph. It is an assignment of colors to the edges of the graph so that no two adjacent edges have the same color. If edges are ordered as e1, e2, ..., en it assigns colors c1, c2, ..., cn in such a way that no vertex connects with 2 edges of the same color.
It is used in several representations of real-world systems like traffic signalling, bi-processors, fiber-optic communication, etc. It can also tell us if a graph is Bipartite. It is implemented in Boost Graph Library (BGL) as Boost::Edge Coloring. It is applicable for undirected and loop-free (i.e no self-loops and no parallel edges) graph. It has a polynomial-time complexity of O(|E| |V|).
ArviZ is a python package for exploratory analysis of Bayesian models. It is designed as a backend agnostic tool and supports different backends for visualisation and diagnostics. Apart from plotting ArviZ also supports functions for posterior analysis, model checking, comparison and diagnostics.
As ArviZ is mainly a visualisation library, it already has various plotting functions to analyse Bayesian Inference data. Still, it would be nice to extend its visualisation capabilities and add some more plotting functions which the community could use.
This project aims to implement dot plots, quantile dot plots, half-eye plots, ecdf plots, and, if time permits, then also calibration plots for classification into ArviZ for both the backends Matplotlib and Bokeh and also to write tests for all these plot functions.
There is currently no open source API format and schema converter that provides conversion to and from multiple formats. The proposed project involves integrating a number of API format and schema converters into a single converter that will be used to convert to and from a number of supported formats. Endpoints for the converter would be developed using Node.js. Following the integration, I will be working on the frontend using React.js and exposing the endpoints to end-users.
Compile latest upstream Android SDK and related platform tools into android-sdk-latest and android-platform-tools-latest packages respectively, for uploading to Debian Sid.
Modern codecs require handwritten SIMD assembly for good performance, much of this has been implemented for 8-bit depth in h264 and hevc but there are still missing for 10 (h264) and 10/12 (hevc).
TTS is an important accessibility function to compensate for gaming experience for those who have trouble reading text, yet the technology is not widely available to ScummVM engines. This project aims to provide the service by tackling engines one-by-one. It identifies four main scenarios of using TTS: Opening Menu, Story Narrator, Gaming Menu, RPG dialogue, and selects games that have at least one area of the TTS scenario as the target of improvement.
Environments are a crucial component of Reinforcement Learning (RL). Grid worlds are a broad class of environments that are fairly popular for testing and comparing various RL algorithms. They also provide immense flexibility to create customized environments that aid in designing algorithms that achieve specific desirable properties (like safe exploration, say). GridWorlds.jl is a Julia package that not only provides a suite of grid world environments out-of-the-box but also facilitates the creation of custom environments.
Multi-Agent Reinforcement Learning (MARL) is a sub-domain of RL for which, at present, there aren’t enough environments in the Julia ecosystem. I aim to fill this gap by providing efficient implementations of some MARL environments as part of the GridWorlds.jl package, and add at least one experiment in ReinforcementLearningZoo.jl that demonstrates an end-to-end workflow for MARL in Julia. Since GridWorlds.jl uses the same API (ReinforcementLearningBase.jl) as used by ReinforcementLearning.jl, RL researchers will easily be able to experiment with MARL, using out-of-the-box algorithms from ReinforcementLearningZoo.jl and environments from GridWorlds.jl.
Knative is an extension of Kubernetes and is specifically designed for serverless workloads. Knative Serving, as one of the core components of Knative, runs scalable containers based on ingress gateway as its network layer to route traffic and control the flow of API calls. Currently, Istio is the default ingress gateway of Knative Serving. Other community-based gateway implementations such as Kong and Gloo are also supported.
APISIX, a dynamic, real-time, and high-performance API gateway, comes with an ingress controller which can be used in Kubernetes. The ingress controller of APISIX, however, has no support for Knative. This limits its use scenarios. This project aims at providing support for APISIX for Knative. Main tasks include
As a result, APISIX ingress controller will be an alternative Knative network layer to manage ingress traffic.
As the number of challenges on EvalAI are increasing, we want to focus on improving the performance of our services. As a first step, we will focus on monitoring and measuring all the key metrics of our services. Insights from these will allow us to efficiently utilize our infrastructure, improve uptime and reduce costs. The project will concentrate on setting up metric reporting and alerts infrastructure, writing REST API’s, plotting relevant graphs and building analytics dashboards to help EvalAI admins maintain and monitor the services.
Apache CloudStack’s persistent networks have been a solution for system administrators, that abstracts away the micromanaging of resources like virtual machines and physical devices (like routers and switches) and avoids the inconvenience of setting up the network for every individual host. Even though the persistent network is quite powerful, it lacks a dynamic to simply add a new host to a cluster and have it automatically configured for the persistent networks resources of the zone. The project idea aims to introduce a feature to CloudStack, with which detecting newly added hosts and creating the persistent network’s resources will be automated to further reduce the management of a cluster during its lifecycle.
This proposal aims to focus on some of the primary goals the repo orcamap-react needs to support the visualization of hydrophones, orca calls, ships, sightings (can be weather, and ocean natural phenomena, too) and increasing the engagement of users with the feature to subscribe for further notifications. Developing different layers as a reusable component to onboard different data can help us to reuse them with other projects too (like orcasite and shipnoise).
Symbiflow has already produced a model of Xilinx's Artix7 in VTR, but it only limited to single chip description. The aim of this project is to instead investigate how to describe Artix7 at a higher level of abstraction, using VTR's architecture description language, so the chip definition cab easily be changed to make conducting experiments with related architecture easier.
The prior goal of this project is to implement a new fairness package that is well integrated into the mlr3 ecosystem. This new package could be used by many other mlr3 subsystems like mlr3pipelines, mlr3tuning and mlr3proba. Then further help the researchers and industrial users to detect the fairness of datasets or algorithmic bias more easily, which could benefit the accuracy and impartiality of their models built by mlr3. The project may also involve some debiasing algorithms in recently published papers due to the connection to mlr3's tuning facilities.
EvalAI is a platform to host and participate in AI challenges around the globe. To a challenge host, reproducibility of submission results and privacy of the test data are the main concerns. Towards this, the idea is to allow users to submit a docker image for their models and evaluate them on static datasets.
Moreover, Github-based challenge creation allows challenge hosts to use a private GitHub repository to create and manage updates in a challenge. The idea is to support bi-directional updates for challenges created using Github. This feature will allow hosts to sync changes from EvalAI UI to their challenge Github repository.
The io_uring is a relatively recent feature for asynchronous I/O in the Linux kernel. It's faster and more efficient than the older async IO features like select, poll, and epoll. NBD being an IO protocol the implementations will benefit from an io_uring.
The major goal of this project will be to embed an alternative io_uring based implementation libnbd and make it faster on kernels that support io_uring (v5.1+). Consequently, nbdcopy a utility that copies from and to nbd servers will be made faster and will also be an example of how to use libnbd with io_uring support and a rough idea about performance improvements. Hence, the minor goal will be to measure the efficacy of io_uring based implementation.
Hopefully, by the end of this project, a bare-bones implementation will be spun-up which can be further improved easily.
In recent years Sync and Share Services have become more relevant than ever in our day to day lives. The scientists at CERN are not an exception to this, however, due to the sensitivity of data they are wary of using commercial platforms. To fulfil this requirement the CERN IT-ST team introduced CERNBox, which allows scientists to collaborate and use their favourite tools in their workflows with ease. This project extends the capabilities of CERNBox by making large data stores readily available within CERNBox. Rucio has decades of experience in scientific data management for various experiments at CERN. Adding CernBox as one of its storage systems will allow users to efficiently share very large datasets across cloud instances and use that data in web-based notebooks making data analysis and experiments reproducible.
My proposal is to develop the Apertium Browser Plugin.
The current Geriaoueg plugin is out of date, with the official link given in the wiki being unreachable and the 2014 version on GitHub being completely unusable on both Firefox and Chrome.
The extension I plan on making will have three main functionalities:
This project aims to revamp the Netengine library making it compliant with the NetJSON Device Monitoring spec and integrating it in OpenWISP Monitoring to create an SNMP check that pulls information from devices to create monitoring charts.
New tests have to be written using mocks to simulate responses from real devices, and the entire codebase has to be ported to Python3.
Information obtained from an Inertial Measurement Unit (IMU) is constrained due to physical limitations such as noise, drifts, misalignments and offsets. Since obtaining the state of a robot/vehicle requires integrating IMU outputs with time, the errors in the integrated estimates grow very fast. This project develops tools to accurately model the errors that affect IMU outputs, to estimate their relevant parameters and to understand how each parameter changes with time. Additionally, a sensor-fusion based pipeline is proposed for regularly correcting the estimated IMU parameters. The proposed method does not require any external mechanical setup and is designed to ideally work on low-computation processors and/or microcontrollers.
This project aims to implement and integrate the likes of Google Licenseclassifier, GitHub Licensee, and other alternate license detection and copyright scanning tools in the form of packages to be used along with Scancode.io.
The second part of this project included enhancements in asynchronous scanning of the codebase using Celery, along with scan result alert in the form of Web Push Notifications.
In this project we want to get to the point where all the wikimedia portals use the same build system and resources. By Using (templates, scripts, styles) of www.wikipedia.org we can get the same build system to all sister portals.
The aim on this project is to implement NEON functions into SIMD which are not yet supported. Adding these implementations will allow the NEON SIMD intrinsics to be run on any architecture. Along with their portable implementations, implementations using other ISA extensions will also be included. For example, SSE/AVX, AltiVec, WebAssembly (WASM) etc.
Figures play a central role in the life cycle of all kinds of research and analysis. That is: The communication of results.
What we propose in this project is to extend pandoc’s figure handling capabilities to represent composite figures. This will provide a concise way to construct them compared with the alternative of writing LaTex code; and thus, facilitate source publishing.
The SciML DiffEqOperators.jl library allows to solve PDEs by transforming them into ODEs via finite difference discretizations and carries support for automated discretizations of symbolically defined PDEs. Basic Linear Operators for derivative computations and common boundary conditions handling exist but others relating to Vector calculus computations are still required for more realistic problem handling. The symbolic handling using MOL discretizations works for preliminary setups and craves for a lot of Add-ons like higher dimension handling etc. Apart from these, enhancements with respect to memory allocation and concretizations of new operators would be a plus. This project would aim to provide these functionalities so that the package caters more generic problems with an enhanced interface.
Interaction of a robot with the operator (human) is an important and daunting task. The aim of this project would be to create a clean, modern and modular Graphical User Interface (GUI) for the conversationalAgent component of RoboComp Viriato. The desktop application will be written using the Electron framework. The app would support one or more open source free to use Text to Speech engines like Mimic or MaryTTS. Combining such a TTS engine with a translation engine can enable the robot to converse in any of the given languages with the user. Leveraging various conversational skills provided by the chosen TTS engine like Mycroft’s Mimic (for example, intents, statements, prompts, confirmations, conversational context) can further help make the conversation feel more real and closer to an actual human conversation.
The idea behind the project is to change the existing tensorflow lite example with TensorFlow Lite Task Library. TensorFlow Lite Task Library is used to gain high-performance gain with easy data processing. After getting selected, I would be changing the existing tensorflow example of BERT Question and Answering, BERT Text classification and Smart Reply using the TensorFlow Lite Task Library for android and ios mobile application.
JTF is a new JSON-based format for transliterations that aims to make cuneiform textual data easily accessible for processing and modifications. It comes with a NodeJS API, jtf-lib, to provide an ATF format parser and converter, a CRUD interface, and a module for sign list operations, jtf-signlist. A React web application, uqnu, is being developed to import transliterations from files, validate, edit, export, etc. The task is to integrate this infrastructure into CDLI's framework and allow crowdsourcing and individual work on texts.
The field of Model Predictive Control (MPC) has seen tremendous progress. The algorithms and high-level software available to solve challenging nonlinear optimal control problems are significantly used in mobile robots to optimize in real-time their path following and navigation. In order to solve Non-Linear Programming Problems (NLP) – which is considered the general form –, we will use CasADi, an open-source tool to solve non-linear optimization problems. Also, the robot should be able to avoid obstacles in real-time by taking into consideration some constraints and penalizing the control values. In practice, previous maps and laser values are combined to create a list of convexified obstacle-free regions. To comply with the real-time requirements of a physical robot, the algorithm will be able to adapt – also in real-time –to the current situation by trading off between execution time and the number of constraints.
In this project I would first need to get acquainted with the reactome pathway system, the existing tools and methods, and the simulated data. This shouldn't take too long, so early enough I would start with implementing methods for obtaining graph embeddings, such as graph convolutional networks (GCN) and message-passing neural networks (MPNN), as they have so far proven to be quite effective in tasks on graph and can easily generalize to graphs unseen in the training set. Following would be testing the implemented methods on the simulated data and debugging, after which I would focus on comparing results obtained with different embedding methods and looking for improvements. Last few weeks I would leave for code refactoring, implementing a simple interface for the client, and final testing and debugging.
Currently bpftool as a userspace utility tool living in the linux kernel can do ebpf feature probing: bpftool feature probe. As the Go+ebpf user-base is growing, it would be useful to have the possibility to probe the kernel for available ebpf features from other userspace programs written in Go without having to shell out to bpftool.
This proposal is about adding a feature probe API to cilium/ebpf that gives users a standardized interface to query the kernel for available ebpf features, furthermore encouraging the use of Go within a fast growing ebpf community.
The aim of the project is to create a cookie manager to manage cookies as required by GDPR and other privacy regulations. Nowadays it’s a need of each of the websites on the web.
Benefits of using cookie management system:
With the 3D scene visualization, viewing data in three dimensions gives users new perspectives. 3D viewing can provide insights that would not be readily possible from the same data's georeferenced map. Currently, MapMint can process the georeferenced image but, since there is no feature provided to the user for viewing the data in three dimensions, which provides the user a new way of analyzing the data. In this project, I will be implementing a 3D visualization as an add-on feature to our earlier services provided by MapMint.
Retain active status of authentication tokens Many testing techniques interacting with web servers such as XSS rely on ensuring authentication obtained on a target be kept active. A mechanism for registering and maintaining open authentications identified during a test for the duration of the console session may provide an additional utility to enable more modules to target techniques that need valid authentication to be maintained. One such authentication token would be data retained in a cookie for a web service. This project would lay the groundwork for registering gathered or generated authentication tokens against a target to be refreshed and sustained until a console exits, or in some cases across console restarts. For this, I will focus on adding support and implementing a way for persisting (keep active) web sessions in some of the main open source CMS like Wordpress, Joomla or Drupal. With this you will be able to keep active a session after getting the tokens or session data to enable more modules to target techniques that need valid authentication. Also, I will make Metasploit store all this data obtained for other internal usage.
Hexagonal binning allows large datasets to be visualized and prevents overplotting of data, where points overlap and turn into a solid mass and information from the visualization is lost. This is useful in finance because of the large datasets used in studies (the U.S. stock market has 4,000+ securities), but is also applicable to other fields. Hexagonal binning is conceptually simple. Bin size scales with the number of points, allowing any number of points to be represented by a single bin, helping the observer to clearly see the density of data and additional visualizations (regression lines, groupings, etc.). Currently, such plots are generated using the {hexbin} package, which has two major issues.
We will create a new package, {gghexbin}, to replace the existing {hexbin} package, which will integrate well with {ggplot2}, the most powerful and widely used visualization package for R. We expect that {gghexbin} will give improved performance and allow for use in a variety of fields.
The main aim of this project is to improve the environment of the remaining 6 drone exercises and migrate them from ROS-Melodic node-templates based Robotics Academy v2.1 to web-templates based Robotics Academy v2.3.
Develop and introduce a new exercise- Drone Package Delivery in ROS-Noetic and Gazebo-11.
This project focuses on the improvement of the live capture section implemented in the spectral workbench app at https://spectralworkbench.org/capture/ to make use of the spectral-workbench.js library after adding some enhancements to it. Additionally, this would require the new live capture code to be adapted to interface with the rails server in order to fetch recent spectral calibrations, display them in a dropdown, then make use of the chosen calibration spectrum to display a scaled x-axis on the live capture interface graph before finally handing off the calibrated data to the rails app after user authentication.
MGnify is a freely available online service hosted by the European Bioinformatics Institute (EMBL-EBI). It helps researchers to do exploration and analysis of publicly available or user submitted metagenomic, metatranscriptomic, amplicon and assembly data. These analyses can be very resource-intensive and sometimes takes many days to complete, even on HPC clusters. It makes it infeasible for small research groups or individuals to perform these analyses on their workstations. So, MGnify is an invaluable resource for the community as it makes these analyses freely available for everyone.
MGnify currently runs on the EMBL-EBI High-Performance Computing (HPC) cluster. However, due to increasing data volumes, the MGnify team needs to scale up the service to keep it in good health. Part of this effort is to enable the MGnify service to run on heterogeneous compute clusters.
This project aims to build a system that can coordinate the execution of jobs within a set of distributed compute clusters. It will act as an abstraction layer to hide the complexities of distributed heterogeneous compute clusters and provide a unified interface to interact with and monitor the service.
The Code is science website is currently built using vanilla HTML, CSS and JavaScript with Ruby as part of its backend. The current frontend needs to be redesigned and updated.
Graphs are a ubiquitous and versatile data structure, which allow the representation of problems and systems across a vast array of domains like infrastructure networks, molecular models, language, and social interaction. Recent community work on graph computations has culminated in a standard API which casts graph computations as generalized linear algebra on sparse matrices. This enables performant, standardized graph algorithms which are easily differentiable by modern auto-diff tools. In this JSOC 2021 project I aim to provide automatic differentiation rules for all of the operations in the GraphBLAS C API which admit such rules. The SuiteSparse GraphBLAS (SS:GrB) implementation will be the primary target, and support for the several extensions to the specification in SS:GrB is also a goal. The primary application I am pursuing is an efficient implementation of graph machine learning in Julia, but it should be noted that graph computation and generalized sparse linear algebra have incredibly broad use cases including graph algorithms like breadth first search, and faster neural networks by taking advantage of sparsity and operators faster than typical multiplication.
This document is related to project proposal regarding GSOC 2021 for OpenMF project. OpenMF is an open-source forensic tool for Android smartphones that helps digital forensic investigators throughout the life cycle of digital forensic investigation. OpenMF tool is available to extract data from a rooted Android device using command line or webclient.
Joomla is a free open-source content management system that helps run thousands of businesses online and is backed by an awesome open source community striving to make the product better. Project Idea 3 works on enhancements of some pre-existing features of Joomla like Menu Items and Article Edit View along with the introduction of a Cookie Consent Manager.
EAT is a testsuite to develop tests against infinite number of JBoss servers. It’s an innovative tool because it’s creating the test once and testing with any version of the tested software. The idea behind the project, the AT (Additional Testsuite) structure, covers a wide variety of new features that could be added to it. One of them, is the addition of a CI (Continuous Integration) tool to perform some automated testing operations. EAT is available for a number of server configurations and a CI pipeline can be built using the maven tool.
The Clacc and Flacc projects aim to introduce full OpenACC support to Clang and Flang compilers. Currently, no mechanism exists for offering OpenACC diagnostics as a result of OpenACC-related calls since these projects are being developed on top of LLVM’s OpenMP runtime, which only offers OpenMP diagnostics for OpenMP runtime calls. This project will address this issue by providing a mechanism to display OpenACC versions of diagnostic messages as a result of OpenACC runtime calls, as well as creating OpenACC translations for OpenMP diagnostics that are already available. Additionally, this proposed mechanism will not be limited to OpenACC diagnostics shall and be generalized enough to allow for extension to other programming languages.
With the addition of deferred length variables in Fortran 2003, users are provided with a utility to leave the responsibility of allocating adequate size to the character variable on the compiler. A deferred length variable is either a pointer or allocatable. Compiler during execution allocates size based upon the value assigned to the variable. For eg: If the value to be assigned to the character variable is 'spiderman', then the compiler will automatically allocate space equivalent to the size 9 and a reference to this space will be stored in the variable. Now if a new character sequence (let’s say 'batman' of size 6) is assigned to this variable then the compiler will allocate equivalent space to store 'batman' and a reference to this space will overwrite the previously stored reference in the variable. Thus, space required by the variable is constant as it is not storing the actual character sequence, rather it is storing the reference to the space where the character sequence is stored.
Proposed goals of the project:
1). Adding new functionalities to strings module
2). Designing and implementing lists of variable-length strings
To refactor current frontend codebase written in Ember to React with Next, set up code standards, write system tests and improve code quality along with reviewing others work whenever necessary.
MediaCMS is a modern, fully-featured open-source video and media CMS. It is developed to meet the needs of modern web platforms for viewing and sharing media. It can be used to build a small to medium video and media portal within minutes.
It is built mostly using the modern stack Django + React, Celery and includes a REST API. MediaCMS is a very useful project empowering communities around the globe to host their own media and content management system. It also helps educational institutes to manage their media and course curriculum by supporting various media formats like Video, Audio, PDF. Docs, etc.
This project aims to improve on some of the core features of the MediaCMS:
Unlike traditional inverse identification tools that rely on gradient and gradient-free methods, simulation-based inference has been established as the powerful alternative approach that yields twofold improvement over such methods. Firstly, it does not only result in a single set of optimal parameters, rather simulation-based inference acts as if the actual statistical inference is performed and provides an estimate of the full posterior distribution over parameters. Secondly, it exploits prior system knowledge sparsely, using only the most important features to identify mechanistic models which are consistent with the measured data. The aim of the project is to support the simulation-based inference in the brian2modelfitting toolbox by linking it to the sbi, PyTorch powered library for simulation-based inference, development of which is coordinated at the Macke lab.
In this project I will be implementing 3D visualization support and integrate it with MapMint. To obtain 3D visualizations, Potree’s GitHub repository will be considered for this task under the JavaScript language. Using Potree I will be integrating the 3D visualizations to MapMint. The dataset for this work being provided through OpenDroneMap, containing files of the type .obj, .las and .ply. These files are of the UAV imagery format and can be loaded on browsers through Potree’s tools and loaders. This will be followed by adding a switcher tab as an addon feature to visualize the OpenLayersMap and 3D visualization. Using this, the user will be able to visualize the 3D scene of a corresponding Georeferenced image.
WellcomeML is a python package containing a set of utility functions that use machine learning for reading, processing, embedding and classifying academic text data like publications, grants, and other documents. The need for developing a new feature for expanding WellcomeML with further visualisation modules has emerged; in this specific case the objective is to create a standard interactive visualisation tool for the results of the clustering algorithm present in the library. In this Google Summer of Code proposal after a presentation of my contact information and technical skills the focus is moved on the project objective and how with the mentors we have been planned to tackle its solution.
The goal of this project is to offer a formal verification using TLA+ for TiKV’s new “Async Commit” transaction model, which brings us more confidence in the improved performance.
Building upon the work done in GSoC 2020 to make programming the PRU easier for beginners, this project aims to add tests, features, and more compatibility for simpPRU, the simple Python-like language that compiles to PRU C and runs natively on the PRU. More specifically, I am planning to add support for the BeagleBone Blue, add unit tests for every language feature, add hexadecimal support for ints, add support for modulo and bitshift operators, support for a new char/uint8 data type, support for a simple array structure, adding a more flexible for loop, and adding the ability to send more complex data in the form of strings through rpmsg and receive them in simppru-console. I will also improve the error handling in the parser and fix known issues in simpPRU. This will make the overall language more robust and complete, which will help beginners learning to use the PRU or experienced users prototyping something on the PRU.
The primary aim of this project is to bring professional efficiency by reducing boilerplate code, increase test coverage reducing the number of configuration lines with the addition of some new features like reusable tokens and server-side logging. This also needs browser testing for success and failure validation responses with selenium.
This will make the code of openwisp-wifi-login-pages more robust to handle any stressful conditions with backend openwisp-radius.
The three languages that this application targets are closely related Balto-Finnic languages spoken in geographical proximity to one another. Finnish is a large majority language with very advanced NLP infrastructure, whereas Olonets-Karelian and Karelian represent two orthographies in this Eastern Finnic dialect continuum. Both Olonets-Karelian and Karelian have written use and linguistic resources, such as Universal Dependencies treebanks, but the resource landscape is still very scarce. One of the current infrastructure problems is the imbalance: some languages and language pairs are much better covered than others. The proposed application aims to bring three closely related language pairs to comparable levels in bilingual dictionary coverage.
LORIS is an open source data platform that stores data important for numerous ongoing neuroscience projects. These data include brain scans, genetic data, psychological tests, and much more. Used in 22 countries around the globe, LORIS currently hosts many well known datasets such as the UK Biobank and the BigBrain 3D atlas.
The objective of this project is to further the development of LORIS by maintaining the codebase, implementing automated tests, and supporting the LORIS team with various tasks so that the organization remains on track with their roadmap.
Currently the open event frontend is implemented in Ember.Js. The plan is to shift the UI to React page by page.
MJIT is a Just-In-Time compiler bundled with ruby2.6 and this enables Ruby to be executed so faster on specific benchmarks. However, it is still a developing technology and some memory-intensive workloads like Rails apps where Ruby is typically used might not be effective at the moment.
I plan to implement an easy and useful benchmark tool which can be used when optimizing MJIT or Ruby virtual machine. This includes a set of real-world rails applications and helps vm developers easily measure real-world performance in their developing ruby.
This project aims to develop a flutter build native interface to ease the group traveling (or hiking). By using this, the group leader would be able to share his location with the entire crew, and in case if someone loses contact with the group he can quickly get in the right place by following the route.
A quantum gate can be decomposed into an already declared sequence of universal quantum gates in QuTip. If the desired decomposition is different from this predefined sequence then the functions proposed for this project could be used as an instance of n_qubit_decomposition class. Any arbitrary quantum gate can be decomposed into a product of universal gates via different methods. The proposed methods differ due to the type of gates chosen to form the universal gate set.
Exporting and importing functionalities for OMRS metadata types is a must-have feature for OpenMRS instances, this provides the users with the functionality of exporting some metadata from one instance and importing it into another or to backup the existing metadata. With this project, upon completion, the users will get the functionality to export and import period indicator reports, which is one of the most crucial report types in OpenMRS
Oppia brings forth a platform to conduct comprehensive courses in the form of classrooms. A classroom contains many different topics in it. At present, there is no way for a learner to track their progress in different classrooms. This project aims to solve this and also incorporate planning and recommendation of topics, subtopics and stories to the learners.
VulnerableCode has a large number of pending tickets that require adding more data sources of known vulnerabilities (aka. importers). As importers sit at the heart of VulnerableCode, the primary goal is to improve their efficiency and implement as many of them (at least 15) as possible.
The SPP and USDLP are the CCSDS recommended protocols used to efficiently transfer space application data through different space-links such as ground-to-space, space-to-ground, space-to-space, or on-board communication links. As of now there are very limited available implementations of SPP and USDLP. Implementing these protocols will be of great help to amateurs and students who find it difficult to get their hands on an open source solution with community support.
Zulip provides powerful utility for bots and integrations, but parts of the system (like embedded bots) are still work in progress. To encourage more users to use the bots and integrations, and to also foster a better development experience with bots and integrations, this project aims at implementing better UI for the users to browse through available bots with verbose description, provide more developer-friendly interfaces for creating bots, and other related tasks to improve the bots system.
Display a list of available bots for all users and show accompanying descriptions or help messages. This sub-goal will be aiming at improving the UI to show more information about the bot.
Propose a way to raise custom errors from the API layer instead of leaving the error message from the server as is (e.g. {“result”: “error”, “msg”: “foobar”}) and requiring the developers to parse the error message to handle cases of error.
Support standard commands while keeping our layer of bot as thin as possible and allow standardized metadata to describe the behavior of our bots.
In this project we will look at loop transformation heuristics, such as the unroll factor.
Currently, App Inventor does not have an element in the user interface similar to RadioGroup in android. As part of my GSoC proposal, I plan on adding a CheckBox Group component to the user interface which would automate the task of unchecking the rest of CheckBox’s in a group once one of CheckBox is checked.
However, it can be implemented using existing CheckBox and blocky editor but it is quite tedious and it’s not scalable. It would be better if this feature is natively implemented as a user interface and it could use the platform-specific implementation of this technique.
Include all test cases and integrate the current CPU implementation of Conv3d with TMVA within the ROOT framework which was developed as part of GSoC last year (https://github.com/root-project/root/pull/6263). Furthermore, to develop and integrate a GPU-enabled version of Conv3d in TMVA (ROOT).
We aim to improve several computations in dynamics and also implement new features. Improvements include optimizing the automorphic group calculation, as well as extending several minor functions to work with dynamical systems on subschemes and in higher dimensions. These minor improvements include extending the computation of the sigma invariants and the multipliers to higher dimensional dynamical systems, as well as extending wronskian ideal and critical subschemes to dynamical systems on subschemes. Finally, we aim to implement computation of the dynatomic cycle, which gives equations defining the minimal preperiodic points, as well as Stoll's reduction algorithm for zero dimensional varieties, which computes reduced equations defining a given variety.
As noted by SimonPoole, the current opening hours parser lacks a complete evaluator for its input opening hours. This project will center around building an evaluator to determine if an input of date and time translate to being opened or closed on the basis of an opening hours string, accommodating sunrise/sunset and holidays information. The evaluators will be in the form of a data structure resembling a compact calendar. The information on sunrise/sunset and holidays are taken externally, possibly using other open-source libraries.
EOS User Story provides an interface to the users to share how they are using the product and relate to other users’ stories and vote them up. It helps users tell developers how they are using the products and request new features, report bugs, etc. The project aims to enhance the user experience by introducing new features and improve on the existing ones. These features include providing users the functionality of sharing stories with a single click, providing request templates for products, personalized email notifications, priority labels for stories, priority based sorting of stories, and a feature for users to mention other users in the comments section.
The objective of this project is to create a new string formatting function, similar to printf in C and format in Python, in MariaDB to avoid complex select statements full of CONCAT() and FORMAT() functions.
The idea of this function is to format each field with existing formatting functions available in MariaDB, so the syntax has to be designed in a smart way to easily accommodate future additions.
nIME:nIME (short for nine IME, pronounced nie-em-ee or nine-em-ee) is a proposed IME for inputting Japanese into plan 9's rio environment that more closely replicates the modern IMEs on other operating systems such as anthy, fcitx, or Google's IME
The Computational Geometry Algorithm’s Library has a program that demonstrates the package named '2D Regularized Boolean Set Operations'. This Project aims at adding more features to the demo, such as, supporting Boolean operations on polygons bounded by polyline curves. Implementing a console will be another important feature to add. Apart from that I plan to enhance the UI/UX and implement exception handling to prevent the demo from crashing. In short my main objective will be to add a few more features and fix both minor and major bugs to match the level of this demo to the current standards of the library.
Setting up a workflow for importing new translations, recruiting new translators along with fixing HTML parsing and UI shortcomings by fixing CSS and helper-function related problems.
Scipy is the fundamental library in Python for scientific and technical computation. CuPy is currently supporting many functions provided by SciPy. But there are many functions that are still not supported in CuPy. My primary aim was to improve the sparse matrix module. Therefore, I plan to do the following during this summer.
Currently parameter configuration of DolphinScheduler is mainly based on configuration files. However there’s no way to override parameters when the same parameter is passed as JVM parameter at server startup. This project is about introducing parameter injection from java JVM arguments to server runtime, so that one can override a particular parameter which is externalised to a configuration file.
Educational institutions, open-source projects and private organizations have the need to create and maintain educational content such as classes, assignments, handbooks and onboarding material. This material is often stored as binary files and shared manually by email or extractable drives. This means that it often gets lost when people leave their organization, changes go unnoticed and error fixes take long to apply and share with the students. This makes collaboration very difficult for both the educators and the students.
That's why Courseware as Code brings the good practices of DevOps and CI/CD into education.
Using git for version control and markdown for formatted text, institutions will now be able collaborate and keep track of their educational content.
Plus by using Gitlab CI/CD pipelines, new and novel ways of interacting with this content opens up.
But building this workflow from the ground up is tough, especially for non-technical users. With a good template, clear documentation/tutorials and already implemented CI/CD pipelines, we plan to make it easy for any user to spin-up their own Courseware as Code implementation.
This project aims to build an automated Twitter bot, using PyBaMM's wide range of abilities, that
This, in turn, will be beneficial for the ever-developing PyBaMM's codebase by making it more efficient and bug-free.
This will also improve our understanding of degradation mechanisms by generating random simulations and will be beneficial for the publicity and the overall visibility of PyBaMM.
A newly added idea of LoopNest pass enables to handle a loop nest efficiently, unlike function pass or loop pass.
The goals of this project are:
Halide is a programming language that facilitates writing high-performance image processing pipelines. Its compiler internally uses a Term Rewriting System (TRS) in order to simplify complex expressions, which comprises over a thousand handwritten rewrite rules added by human compiler engineers. In order to strengthen the TRS by finding new rules that can rewrite input expressions that the TRS currently fails to simplify, a synthesizer was used to automatically generate 4127 verifiably sound rules. Experiments have shown that adding these rules lowers peak memory usage by up to 50%, while having relatively insignificant impact on runtime performance. However, adding every such rule increases compile-time and compiler code size. This project aims to address this problem by incrementally testing and assessing each rule and subsets of the rules, while adding them to the compiler only if they necessarily contribute to the peak memory reductions shown in the experiment or other improvements in performance.
This project aims to build and implement mdox, a documentation automation CLI tool, which can keep project documentation completely up-to-date by validating remote and local links, formatting markdown using GitHub Flavored Markdown guidelines, and generating code thereby making the act of maintaining quality documentation much easier and ensuring that this documentation is readable from GitHub as well as a website.
Clean up the cifsdebug.c file. Possibly generate a hierarchy of /proc files. Make a nice visualizer/dashboard thing to get an overview. This could be console or GUI.
This GSoC project aims at extending the tests in Libreoffice. There are currently more than 1300 bugs fixes which do not have tests written for them, so this project aims to bring down that number. The tests with the highest priority will be written first followed by lower priority. Most of tests will be written in C++ using CppunitTest framework and the UI tests will be written in Python using the Python UI Test framework.
TensorFlow Model Garden and TF Hub provide a lot of state-of-the-art models for TF developers to use easily in their research and product development, so, the key feature in these tools is to provide state-of-the-art models and this is what the project is about. So, the mission of the project I’m applying for is to join a team on the quest of training new SOTA models and publishing them. For this, I have devised this problem into 2 sections:
A major requirement for the current status of the dashboard is the implementation of a download and install pipeline for tables having spatial data in the form of vector images/data. According to the retriever docs, currently the retriever library uses the PostGIS extension for the same. Therefore, the install process to be used for the dashboard will make use of the postgres engine. The spatial datasets are already tested for only download and changes are detected using the md5 hash. This proposal will further that, into proper install of these datasets into Postgres and find out diffs in the databases using PostGIS joins. The results obtained will then be converted into HTML diffs just like we do for non-spatial databases.
The Authentication server of the litmus portal (which resides in the litmus-portal folder of the main litmus repository) is written in golang, uses certain outdated dependencies (such as mgo), and currently does not support third-party OAuth authentication modules such as:
The current implementation of the authentication server also consumes more resources than the litmus portal’s GraphQL server.
This proposal shall focus on re-writing the Authentication Module of the litmus-portal so that it achieves the following:
Adapt the remaining algorithms like unique, adjacent_difference, lexicographical_compare etc. to C++ 20 and to Ranges TS.
Orbit Satellite visualizer and other space related concepts displayed in Liquid Galaxy ecosystem.
The project PyAfipWs under Python Argentina(PyAr) is a library for Developers & tools for accountants and SMEs.It is a wide-spread standard reference implementation to communicate with Argentina’s government entities, with more than +1.5K users group subscriptions, many bindings to other languages and used in modules for Open Source ERP localizations (OpenERP, Odoo, Tryton, etc.) PyAfipWs contains Python modules to operate with web services regarding AFIP and other government agencies, mainly related to electronic invoicing, several taxes and traceability. Aim is to merge back changes from previous GSoC,updation of code,add unit tests upto 85% coverage, convert script into python entry points,resolving problems in setup.py,support for dbf tables,xml,xls sheets and possibly other libraries,Integration & deployment with github actions to upload to pypi and use of pytest VCR for Unit test.
This project strives to support distribution of libraries for large-scale data processing and computation on Gentoo Linux. In particular, it will focus on big data software built upon the Java platform. The project will be based on java-ebuilder, a tool that creates a Gentoo package for any Java library hosted in Maven Repository, and a Spark overlay done by Zongyu Zhang for the previous year’s GSoC. It will improve upon these resources to ship the H2O Machine Learning Platform and Kotlin libraries on Gentoo, in addition to Apache Spark and the Java libraries that the Spark overlay already provides. It will also introduce utilities for testing both java-ebuilder and the software packages in the Spark overlay.
The backup and restore tools provided by GitLab are relied upon by administrators of GitLab instances as part of their disaster recovery strategy. These procedures rely on standard UNIX tools such as rsync and tar and cover most data excluding GitLab configuration.
There are a number of ways that we can continue to improve the backup and restore processes to make the experience more reliable, efficient, and transparent for system administrators.
Result reporter tool to convert linter/bear results into multiple formats.
make a User Interface that presents some context of the word in form of a dialog or a video that includes the word or the whole sentence ,that will ease the understanding of the word and leads to a better translation .
Implement a cache for closed tabs, such that reopening a recently closed tab will be instantaneous.
To develop an Android & IOS application to provide clinical decision-support for nurses and doctors delivering essential newborn care interventions during the first day of life. This application provides knowledge, skills, and competencies to nurses and doctors in low/middle-income settings so that they can provide life-saving care to newborns from birth through 24 hours postnatal. App uses DHIS2 as backend & can be setup for any hospital/organization
debug.rb is a replacement of the traditional lib/debug.rb standard library which is implemented by set_trace_func. New debug.rb has several advantages. However, it is hard to write test codes for them.
This is a proposal to implement tests for a debugger based on deivid-rodriguez/byebug: Debugging in Ruby 2. Test codes for byebug consist of two parts. The first part is the test framework for test byebug. It extends minitest. The second part is tests for byebug using the test framework. It doesn’t test each method, but situations such as the existence of a breakline. I will implement test codes for debugger referring to them.
While KDE Plasma on the desktop has robust calendar, tasks and journal management capabilities thanks to KOrganizer, Plasma Mobile currently lacks such capabilities. Existing applications are hampered by an absence of Akonadi integration, which would allow users to synchronise their data across applications in Plasma.
The reason for this is that there is currently no existing Kirigami/QML implementation of a calendar that integrates with Akonadi. Carl Schwan recently began developing a proof-of-concept Kirigami ‘Kalendar’ application that supports a detailed month view and works with Akonadi calendars, but that is currently a work-in-progress project.
This proposal puts forward a plan for improvements to this existing proof of concept that would help implement a fully-featured convergent calendar application for Plasma Mobile. This application would allow the user to view, create, modify, and delete calendar events with full Akonadi integration. This will be made possible by creating components written in QML and Kirigami that should allow for the creation of a visually-attractive and intuitive calendar view components that could be used in any Kirigami application.
Hasktorch has two distinct APIs for tensors: Torch.Tensor and Torch.Tensor.Typed. While the untyped version can initially be easier to use and experiment with, the typed version offers static analysis of tensor’s shape, layout, precision, and compute device. The typed version not only helps with debugging and maintainability but also offers better support for type-driven development via GHC features like type holes. However, it is currently difficult to mix the two approaches, e.g., statically specifying tensor’s embedding size while keeping other dimensions unchecked is not possible. Gradual typing is the proposed solution that fuses the two APIs by adding Torch.GraduallyTyped type. The new API allows for more granular control by letting the user choose which properties of the tensor should be given a static type. The goal of the project is to bring maturity to the gradually typed tensor API, add missing features, and experiment with new ideas.
The mlpack library boasts an extensive set of objective optimizers, almost all of which focus on single-objective problems. Previous works by Sayan Goswami paved the way for multiobjective optimizers. This was further complemented by the addition of Schaffer-N1 and Fonseca-Flemming test suites.
This project aims to add optimizers, expand the test framework and make the library more accepting of multi-objective problems in general. Building from existing work, the end product would enrich the MOO module and package these features to fit into our codebase providing familiar public-interface.
Create and test pre-sorting methods of z-order and Hilbert curve for elements in GiST index to check if it will improve the performance of index building process.
Aim is to build all the portions of the FastAI.jl package, inspired by the fastai Python library, which will provide high-level components that can quickly and easily provide state-of-the-art results for tabular tasks, and provide low-level components that can be mixed and matched to build new approaches.
This will include handling tabular data of all kinds of format, performing transformations on it if required, creating a model using best practices and entity embeddings, and being able to train the created model.
All this will be done without compromising in ease of use, flexibility, or performance, due to the benefits Julia provides, along with the well designed three layered architecture.
The project focuses on the strips (video and image/sequence) in the video sequencer. The main goal is to add a preview of the clip in the corresponding strip of the sequencer to replace the current flat color rectangles and to provide visible icons on the strip for any strip modifications.
Ask SCORE app is the community app, which helps organisation in Collaboration, teamwork, promotion, cooperation with their members(Mentors, Mentees, Students). This app aims to resolve queries by anyone in the organisation and let members communicate in the Forums/Channels.
Who, what, why and how.
Elements of differential geometry enable us to quantify the curvature of a surface. The core elements of biological membranes, phospholipids, provide tridimensional configurations from which a surface can be derived to calculate curvature descriptors. We would like to integrate to MDAnalysis an analysis module to calculate averaged mean and Gaussian curvature from Molecular Dynamics simulations. By integrating a membrane curvature analysis module in MDAnalysis, users will benefit from a tool that enables rapid extraction of relevant properties of lipid bilayers in biomolecular systems. Our approach extracts key elements of the membrane using phospholipid head groups to define a surface, followed by a transformation into NumPy arrays. In this way, the functionality offered by NumPy and SciPy can be used to derive values of mean and gaussian curvature of biological membranes. Since MDAnalysis already works very well to explore data interactively, visualization of the membrane curvature analysis outputs in 2D-maps can be easily performed.
Oppia uses Angular as the frontend framework with typescript as the primary language, hence this codebase is fully typed which implies that variable assignment, procedure arguments and function return values will all be associated explicitly with a type. strict is a typescript compiler option which turns on a set of stricter type rules which, when enabled, helps reduce the chances of getting unpredictable results and makes the code more robust but currently, Oppia’s code base does not pass these strict rules. This makes the code prone to unexpected actions and errors.
To avoid this, the following actions need to be taken:
This project aims to change the tsconfig-strict file to ensure that any new file added to the Oppia’s code base will, by default, have typescript strict mode enabled. Also, strict typing will be introduced to 240 files (120 files and their test file) already present in the code base and listed down in UpgradedServices.ts.
In this project I aim to port a read-only implementation of the XFS filesystem to FreeBSD. The implementation should be done in userland through the FUSE interface and support at least version 4 of the file system. Support for necessary XFSprogs shall be added to be able to debug and test the file system.
Currently, there are no heap-specific widgets in Cutter to get information about the heap while debugging a program. This project aims to solve this by providing various heap visualization widgets and memory maps to provide information about the state of the heap. Another issue with the heap parsing in Rizin is that it depends on how Rizin is compiled and fails for cases of non-native and remote debugging cases. The project will also try to expand the number of heap allocators that Rizin supports. After completing this project, users would be able to get information about the state of the heap in Cutter and do this for cases of remote debugging and a variety of allocators. As part of the project, the following are the key features that will be added and changed:
dmh in RizinTalawa is an open source project helping people with same interest to collaborate together. It deals with managing the members of the group via help of Talawa admin panal. Tawala appilcation helps members to join organizations of their interest via organization's Tawala-api hosted URL.
The Rivet toolkit is a software package for performing data analysis on simulated particle collision events like those in the Large Hadron Collider (LHC). Rivet covers all aspects of collider physics and is the LHC's principle tool for model testing using events simulated with Monte Carlo methods. The current framework for visualizing experimental datasets can be slow and error-prone, and our proposed project will focus on designing and implementing a replacement for this visualization system based on modern rendering technologies while preserving high quality outputs. The goal of this project is to create an intuitive Python plotting package that complements and incorporates a single coherent treatment of the existing classes within the Rivet toolkit. The new visualization architecture will focus on finding a balance between power and simplicity in the user interface, enabling researchers to quickly share their results in beautiful and easily accessible formats. The ability to design interactive web-based visualizations will allow researchers to create engaging and high-quality educational resources for students and individuals interested in physics around the world.
DigiKam is a famous open source photo management software. Face engine is a tool helping users recognize and label faces in photos. Following the advance of Deep Learning, digiKam development team has been working on the Deep Learning implementation of Faces engine since 2018. During the past few years, with the huge effort of digiKam developers and the great support from users, the Faces engine has been improved gradually.
However, the Faces engine still has some issues that were not yet eliminated. For example, in the core algorithm, we still get many false positives because the faces engine tries to include all the faces to the known range of labels. In the face pipeline, a lot of implicit memory conversion between QImage, DImg and OpenCV Mat, which for some reasons, adds noise to the images.
Therefore, for this 2021 Google Summer of Code, we are going to improve the detection/recognition performance with outlier faces suppression (i.e. new faces should not be counted as untagged faces), the ability to work on large datasets, and an ease-of-use face workflow improvement.
Multi-stage decision-making problems widely appear and pose unique challenges in various real-world applications, e.g., robot control, game play, and healthcare. Consider the clinical trial design as an example. Optimizing the clinical trial design is essential to decrease the cost of drug development, as the average costs are up to 52.9 million US dollars for a Phase 3 trial [1]. The current approach formulates multi-stage decision-making as a general Linear Programming (LP) problem, which however, is computationally expensive especially in large-scale settings. In this project, we aim to develop new customized algorithms and an R package for multi-stage decision-making problems with three key features: 1) It provides a highly efficient solver to tackle a large and important class of sparse LP problems; 2) It provides a solution for multi-stage decision-making problems with Bayes risk constraints; 3) It provides additional functions such as visualization of the optimal decision maps.
XFS is a great filesystem and it has become more and more widely used since it was ported to Linux kernel. Haiku began to support it from last GSoC. This year I would like to keep on this work for this file system. The goal of this project is to add XFS filesystem support as we can. Basically, finish patches we have and add extended attributes and symbolic links read support. Furthermore, test tools, more read support and set up for write support are in plan.
OpenLex was developed as part of an Open Source Specialization Program, to provide free legal software for lawyers and small law firms (in a market with no Open Source alternative).
Bugs or Issues are the vulnerabilities that you find on Websites or Applications when you expect some functionalities to occur but something else happens, which can cause some problems from minor to major level such as tempering a website like Amazon to buy things at relatively lower prices.
Here comes BugHeist with an ultimate solution to the problem where users can report bugs/issues and can win exciting prizes or money.
BugHeist lets anyone find and report issues on the internet. If you find something out of place on Amazon or any other website let them know. Companies show their response time and history. Get points on every bug you find on the internet and keep the internet free of bugs.
The idea is to create a:
Flutter Application for the bug hunters and people who want to contribute in making the Internet Bug Free. Having the code which follows the existing style guides, which also passes all the existing quality gates regarding test coverage and code analysis. Requirements:
1. Javascript and Web Development.
2. Google Flutter.
3. Django Rest Framework, and Postgres.
4. Docker Environment.
There are many algorithms implemented in NetworkX some of them being simple and some of them being very complex. Understanding the algorithm that we are using in our projects is very important. One way to understand the algorithm and its implementation is to read its documentation or if one is really interested then read the code. But it's not always possible because of different reasons, maybe the code is too large or it is very abstract and to understand one line of code we have to understand some other function.
The idea of using notebooks for explaining the algorithms which is being carried out in networkx-notebooks will help the community to understand the algorithms more intuitively and easily. But still, there is a long way to go as very few such notebooks have been added so far and there is a large set of algorithms’ awaiting to be added to the collection.
The Syft ecosystem allows one to write software that can compute over information you do not own on machines you do not have (total) control over. PySyft mainly allows direct computation on unseen data and generates static graphs of computation that can be deployed or scaled later.
To do so PySyft creates an AST that maps function calls to their exact path and knows what to do with a node in the tree. AST allows remote execution, and to do so AST provides a local handler for the result of remote execution through pointer alongside generating all the permitted methods and attributes on a Pointer.
The current implementation has integration for pandas’ DataFrame and Series, i.e, one can remotely execute methods and access attributes on objects on these classes using their pointers. This is to be further extended for all the classes and global functions in pandas.
For a long time, the modifier system was the main way to procedurally generate and modify 3D data in Blender. While modifiers can be stacked to produce a large variety of results it has limited control over the flow of data. The Geometry Nodes system, introduced in version 2.92 of Blender allows the user to go way beyond these limitations by building complex processing graphs with an advanced attribute system that allows storing data into geometry to be available for later nodes in the graph to operate on. At the time of writing, only a small set of basic functionality is available as nodes. This project will port a selection of functionality from the old modifier system to the new nodes system, taking into account the atomic design, the attributes system, and the variety of geometry types it operates on.
The proposal conatins an architecture for validating handlers param. This proposal also contains a plan for using the architecture and validating the params on some files of the codebase.
Since we have a working python 3 branch for SPDX Online Tools, it is necessary to keep the app updated to latest Django versions and at the same time update any other third party libraries as the new version of libraries would have new features and improvements along with bug fixes. This change is necessary as the older version of Django will eventually stop receiving security updates and would make the application vulnerable to security threats.
The application code of the SPDX Online Tools which serves the current purpose of client-side consumption and its API doesn’t have a common utility which makes it difficult to maintain as well as test both of these services at the same time. This project will develop a common utility for both app and api by improving the overall structure of the codebase by rewriting the code if needed and make sure test cases run correctly. This would trade off the extra cost and efforts from the developers’ shoulders.
Automatic generating of Hub schema when pointed to a directory, instead of having to manually define it. The aim of this project is to eliminate the need for manually defining schemas.
I want to improve the Linux kernel environment model for more accurate work with memory.
Increase frontend unit tests coverage of AngularJS and Angular 2+ frontend controllers, directives and services to 100%.
Under guidance from the mentors, the student will develop a suite of models for benchmarking Bayesian computation. That involves gathering data/models with a variety of inferential structure for coding and optimization in Stan. The resulting canonical models and posteriors will be submitted for inclusion in the posteriorDB database to serve as reference points against which new approaches to Bayesian computation can be compared.
Enhancing and extending the Point Cloud Library’s clang-bind project to fix and add to its existing capabilities. Currently, the project is lacking in its scope to bind a complete module of PCL to python, and this project would like to build upon that. The aim is to fix existing issues and increase the coverage of the existing scope to develop python bindings of PCL.
We design a simple pipeline for using state-of-the-art speech-to-text, text-to-text, and text-to-speech to create a speech-to-speech translation system as well as text-to-text. Users can then create and share audio or video files that will be translated for them to the language of the other user they want to message.
PyTorch-Ignite is a great library built on top of pytorch. It provides an extremely simple engine and event system to work with, which work really well in a distributed environment. It also has a set of very handy metrics which can be used right out of the box. This is why I would like to become a contributor for the PyTorch-Ignite library. I wish to work on the metrics module because I have worked in Brain-Computer Interface, Computer Vision, Augmented Reality and am familiar with a myriad of different metrics. I am also familiar with using pytorch library and have built, trained and tested many models with it, making me a suitable candidate to work on the metrics module of PyTorch-Ignite. Contributing to PyTorch-Ignite can help me learn more about using pytorch in a distributed environment, writing test cases for your code, get used to the GitHub workflow in general.
Faces of GNOME will be built using modern site generators that will showcase past and current GNOME contributors. It has the intention to create, maintain profile pages letting contributors add custom information, blogs, etc. The project includes introducing bots for automating markdown profiles, adding RSS related features, managing SEO, adding advanced search queries, improving web performance alongside deploying the website using GitLab continuous integration services. The main goal of this project is to have a full code-complete solution, with documentation, guidelines, and all the pages complete and ready to be launched. This project would also allow the Faces of GNOME to succeed as not only as a project and but also as a program.
The project is to make a Program that will record X amount of seconds after it detects that the wake word “Hey Rodney” has been said. After that the program should send the recorded data to the cloud where the recording would be converted to text using speech to text transcription. Optional Part: Making the same program run on an embedded device.
OpenCV is used extensively in computer vision, tackling almost all major computer vision problems. Many Modern CV applications require working with videos, which are essentially images(frames) stacked on top of each other. Potential applications can also include working with audio along with video frames. OpenCV currently doesn’t provide support for such applications out of the box. The goal of this project is to add speech recognition samples, to be used with the OpenCV DNN module, to provide out of the box support for applications involving audio. The newly added AudioIO module can provide a convenient way to read such audio files.
ReactOS is able to launch commands, when the computer started next time, just for one single time using the RunOnce registry, just as what Windows do. This is executed silently and the progress is hard to track.
Meanwhile, Windows also supports RunOnceEx, which has these benefits compared to RunOnce:
RunOnceEx will provide a great convenience for the user who wants to launch multiple commands and show the progress in a GUI, and making those software depends on RunOnceEx working on ReactOS.
This project aims at implementing RunOnceExProcess inside iernonce.dll in order to make RunOnceEx usable.
This project aims at providing documentation and possible patches to incorporate improvements in nls(), including better diagnostics to assist users to understand when output results may be inadequate.
Orbital Graph Convolutional Neural Network is a framework in which the node features also include information about electronic orbitals of the constituent atoms. Since virtually all properties of interest arise from electronic interactions, this adds substantial predictive power and the potential for vastly improved model accuracy. Further, inspired by tight-binding model formalism, introducing a novel means of initialising weights with information from the Slater-Koster tables made available as a prior would theoretically help derive a more accurate and data-efficient representation.
This project is about improving the UI/UX experience of kiwix-serve which is used to host library.kiwix.org and other local servers for hosting zim files. My main focus on this project will be to build a better search and presentation experience for users.
For an open-source tool for bioinformatics like WormBase, it is essential to have thorough documentation of features and use cases. As part of this project, we will document the programmatic access and use of different data available on WormBase and create pipelines for data analysis and visualisation using various publicly available tools. We will help users with easy programmatic access to data with options to filter and refine results per their wish.
There are multiple bioinformatics data analysis tools, both on and outside the WormBase websites. It would be helpful to integrate these tools into several pipelines for regularly used types of analyses. This would remove the need to manually plug in the output from one tool into another as the input.
This project will be highly advantageous to users who are not familiar with the different data that WormBase provides and those looking for an easy way to quickly extract the data they need. Since we also integrate many widely used tools, it will be beneficial to the Worm community, especially pure biologists who want to analyse their data.
GCompris is a software suite comprising educational entertainment software for children aged 2 to 10. The goal of GCompris project in GSoC this year is to add new activities. By the end of GSoC coding period, I'm planning to add the following activities to GCompris:
Deplacements activity Phabricator: T14159
This has 4 different sub activities:
Adding Oware activity Phabricator: T1537
This has two sub activities:
I will be working on adding a new functionality to FURY which shall enable users to visualise various types of proteins via different representations like Richardson aka Ribbon diagrams and molecular surface diagrams. As a part of my stretch goals, I’d like to expand protein representations via other representations including -
In the large majority of cases in DBpedia, it is not clear what kind of relationship exists between the entities. Instead of extracting the triples <subject, predicate, object> from semi-structured data only, we want to leverage information found in the entirety of a Wikipedia article, including page text. The goal of this project is to develop a framework for predicate resolution of wiki links among entities, specifically, we focus on the direct cause-effect relations between events. Our task then is to extract the cause-effect entity pairs (e.g., Peaceful_Revolution, German_reunification) from the wikipedia text. We combine the idea of using the seed data (e.g., the known cause-effect entity pairs) with training a classifier (e.g., a discriminative model--- LSTM ), so as to discover more cause-effect entity pairs from wikipedia text, which is known as distant supervised relation extraction. The procedures include the pattern matching, knowledge exploration, entity recognition, entity mapping, etc. Eventually, we aim to acquire more reliable causal relations between entities of DBpedia.
ShardingSphere parser engine helps users parse a SQL to get the AST (Abstract Syntax Tree) and visit this tree to get SQLStatement (Java Object). At present, this parser engine can handle SQLs for MySQL, PostgreSQL, SQLServer and Oracle, which means we have to understand different database dialect SQLs. This project is focused on proofreading all the TCL (Transaction Control Language) SQL definitions and all the Oracle DDL (Data Definition Language) SQL definitions except for ALTER, DROP, CREATE and TRUNCATE.
The idea behind this task generally revolves around the fact that the smooth and bug-free nature of the graphics rendering of LibreOffice should be maintained for every client system to offer a smooth user experience. There are pre-existing tests that ensure if the former’s the case or not, however, there are still some test cases to be added which would enhance the test’s feasibility thereby helping in examining our graphics more thoroughly. Also, a UI component should be implemented for the users to check the results for themselves so that they could easily provide feedback regarding any graphics issue if present. This task’s main objectives are adding more test cases to the pre-existing tests, running those tests in every backend, and implementing a usable UI for the users to test the graphic’s feasibility themselves.
It is one of the existing project ideas: https://gitlab.gnome.org/Cogitri/Health/-/issues/70
Inlay hints take advantage of Swift's powerful type inference by visualizing inferred types throughout a Swift program in the editor. This makes it easier to read and understand Swift code, all while letting the programmer write concise code, without having to spell out every type. To achieve this, a custom LSP request is introduced that fetches the inferred types of unannotated variable bindings from the language server which, in turn, queries sourcekitd for the required information. The request will be called by the editor, e.g. VSCode, which will subsequently present the corresponding text decorations.
The task is to catch bugs due to race conditions in Linux Kernel 5.4 device drivers. A software verification framework called Klever automates the verification against a concurrency safety requirement specification. Using the Klever web interface, the generated error traces are analyzed and classified as false warnings or real bugs. In case of bugs, a bug fix patch is prepared and sent to the driver subsystem developers, or a bug report is sent. Causes of the false warnings are also determined to improve the tool's environment models.
Verifying the correctness of processors involves a lot of extensive tests. As the state space of processors is huge and tests can never attain full coverage, so formal verification is the sole way to obtain a guarantee. Designing processors is considered an error-prone process. Due to the complexity of the designs, errors often remain undiscovered even in the case extensive testing is done. In this project, an attempt is to formally verify the subsystems of the mor1kx processor using yosys's symbiyosys tool. Mor1kx supports three pipelines whose formal verification will be done using sva assertions and cover statements.
Improve inlining: using subgraph analyze and locally optimal inlining decisions
In this project some new features of the vulnerable code snippets will be added along with a redesign of the score board
For this project, I would like to implement 3D Barycentric Coordinates for Convex Polyhedra with Triangular Faces, which is one of the ideas for this year GSoC. The goal of this project is to extend the CGAL package 2D Generalized Barycentric Coordinates to 3D space, to achieve this, it is necessary to implement several coordinate types, which include coordinates for tetrahedra, 3D Wachspress, mean value, and discrete harmonic coordinates.
Deep learning research is progressing very rapidly & frameworks like TensorFlow makes the process very efficient. TensorFlow enables us to get highly optimized features with just a few lines of code. This enables efficient & faster training on hardware like GPU / TPU’s.
I am proposing to implement Wave2Vec2 in TensorFlow 2. I will be converting all the pre-trained checkpoints to TensorFlow compatible format and will fine-tune it on several benchmarks. This will help researchers / ML engineers to use ASR state-of-art models in TensorFlow & expand their research. I will also work on XLSR-Wave2Vec2, which will enable speech recognition in multiple languages using TensorFlow 2.
Further, I will be deploying fine-tuned Wave2Vec2 on mobile devices using TensorFlow Lite. I will also summarize my learnings in the form of tutorials and blog posts. This will help the community to better understand cutting-edge research in deep learning.
The main objective of this project is to fulfill the most important and much-needed missing REST API endpoints for some of the Django models of the oldest OpenWISP modules. The inclusion of this feature will not only add more usability to these modules but will also help in the faster development of other new features, and also save time during development.
QuTiP's data layer provides the mathematical operations needed to work with quantum states and operators, i.e. Qobjs,. As part of Google Summer of Code 2020, the data layer was rewritten to allow new backends to be added more easily. Backends using in-memory spares and dense matrices already exist, and we would like to add a backend that runs on GPU, either through Cupy or TensorFlow. This will decrease the computation time thus making it feasible to work on larger qubit systems.
The LLVM lit test suites consist of thousands of small independent tests. Due to the number of tests, it can take a long time to run the full suite, even on a high-spec computer. Builds are already distributable across multiple computers available on the same network, using software such as distcc or icecream, so running tests on a single machine becomes a potential bottleneck. One way to speed up running of the tests could be to distribute test execution across many computers too. Lit provides a test sharding mechanism, which allows multiple computers to run parts of the same testsuite in tandem, but this currently assumes access to a single common filesystem, which may not be possible in all cases and a knowledge of which machines the suite can currently be run on.
ZT is one of those very few TUI’s which are user-first and user-friendly as opposed to applications that say - “You can only set this up and running after 5 google searches, 3 articles and 1 stackoverflow answer”. Making ZT accessible for even the most technically knowledgeable person or beginner is my goal. I shall mainly focus on improving the visual feel of ZT along with improving certain event handling capabilities.
gnome-shell allows taking screenshots and has a built-in screen recorder, it can take screenshots and record screencasts of an area, a window or the whole monitor. Right now, screenshots can be taken using the gnome-screenshot utility or by pressing certain key combinations, recording screencasts only works by pressing a key combination. Remembering all those combinations is hard, especially when not using them often, also it turned out a lot of people are not even aware features like the screen recorder exist. The plan for this project is to unify both the screenshot and the screen recorder functionality within a single UI that's part of gnome-shell. This will make it easy to select an area or a window to screenshot/to record, especially on devices like tablets or phones where no keyboard and mouse are available.
DCE currently makes use of net-next-nuse to extend the Linux kernel internals like the networking stack to host applications but over the years the project hasn't been updated with the latest releases of the Linux kernel. This project aims at enabling support for latest Linux kernel features and toolchains in the DCE environment with support for the socket networking stack, sysctl interfaces, system call access, etc. without any changes to the user APIs currently being used by host applications.
Continue the implementation of the course in Runestone Academy. For those lectures in which some code won’t run in the platform due to the modules they use, I have in mind replacing them with other modules. The expected outcome is to have the existing lectures implemented in Runestone fully functional with various exercises with automatic grading, have created new lectures teaching other modules, and have implemented other lectures using Brython.
The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations, and narrative text. To interactively work with Octave code within Jupyter Notebooks, there already exists an Octave kernel for Jupyter. This project aims to support the opposite direction: running (and filling) Jupyter Notebook within GNU Octave. This would enable Jupyter Notebook users to evaluate long-running Octave Notebooks on a computing server without a permanent browser connection, which is still a pending issue.
Whereas Debian has supported Clojure since early 2009, the current Clojure environment in Debian is still quite immature: even as of early 2021, it's still missing many core build tools and libraries. I aim to improve this situation, mainly by packaging the clojure CLI tools and updating the Clojure package to support them. If time permits, I will also improve the quality of both new and existing Clojure packages and the overall Debian Clojure packaging process. Finally, I have to emphasize that I see all this process as a great opportunity to, finally, start my journey towards Debian membership.
This project has as main objective the development of a navigation system for the Liquid Galaxy project, using only voice commands, with a voice recognition and audio transcription API, all programming and code development must be carried out using a board Raspberry Pi 4. This project should have a simple and easy to use interface, so that it can be used by older people, who do not understand technology. It must operate online and offline. It will also be possible to use this interface via an HDMI cable, connecting it to a TV, or using it with a standard installation of Liquid Galaxy, connecting it via Wi-Fi on the same network as the computer cluster. Use cases: Case 1 (Using in a Liquid Galaxy Installation) - The box can be connected using the network info, and send commands to Liquid Galaxy after voice commands. Case 2 (Using as a stand alone device) - The box can be connected to a TV, using a HDMI cable, after the connection the user will see Google Earth in his TV and will be able to start navigating around the world using voice commands. Technologies: Raspberry Pi 4, Python 3, SpeechRecognition, Pyaudio module, Socket protocol, KML files, Voice Recognition API
Slagora is one of those ready-made slack applications that enable teams to create interactive polls using preferential voting algorithms. Slagora makes it easy for slack teams to create polls that will enable the team to make informed decisions. I will be developing a REST API using Scala Play and an admin Dashboard in Angular. This will enable poll creators to easily create polls directly from the Slagora website.
This proposal aim to move Eventyay Open Event Frontend from EmberJS to ReactJs in order to make use of modern web technologies and state-of-the-art techniques to provide users and developers a better, faster and more professional experience.
Currently, mypy and mypyc are unable to recognize uses of the singledispatch decorator, making mypy generate false positives and mypyc generate incorrect or slow code when it is used. This project would improve both of these by adding special support for singledispatch in mypy and mypyc in order to fix these problems.
The project mainly focuses on enhancing the search and advanced search features in the CDLI framework. The objectives of the project are :
CyjShiny is a cytoscape.js R/Shiny widget with an RCyjs-based API (and ancestrally, RCy3). It aims to give users the R Shiny framework which is a way to use Cytoscape to visualize networks over the browser using cytoscape.js. This project aims to add some new functionality, minor customizations, and unit tests to the cyjShiny package and to publish the package to CRAN. The features will include some cytoscape.js extensions, such as animation and styles, and also some integration with Cytoscape desktop. Besides, since cyjShiny needs automatic testing, it'll need to add to the package.
Among all the human writing communication systems and inspired by Google Arts & Culture project Fabricius, we propose the creation of a framework to identify glyphs in Aztec/Central Mexican codex and classifying their Graphical Communication System (GCS) using Convolutional Neural Networks (CNN) Keras. The goal is to create a model with transformed glyphs in RGB-matrix samples to successfully train Deep Learning algorithms as a useful too for Aztec scholars.
A feature allowing users to break intersecting into non-overlapping parts, union or delete the resulted parts.
This project is about developing a Casbin plugin for Kubernetes, which would authorize the users based upon the roles/policies defined in the Casbin policy file to access certain pods or clusters.
Computer hardware is susceptible to errors. For example, radiation may induce error to the hardware and some bit might be flipped. It is important to improve the resiliency of software against hardware errors. One way to evaluate the resiliency of software against hardware errors is by fault injection. Using Java PathFinder, we can explore how a Java program acts for hardware errors. Specifically, we can let JPF simulate hardware errors like bit flips at some point in the program. A bit flip can happen in many positions, such as registers or main memory. We can let JPF explore the possible results of bit flips in various positions concretely, or we can use Symbolic PathFinder to explore symbolically.
CodeLabz is a platform where the users can engage with online tutorials and the organizations can create tutorials for the users. The platform will be developed using ReactJS front end library and the back end will be developed using the Google Cloud Firestore and Google Firebase Real-Time database.
This project aims to improve the overall usability of the Purr Data Web Application to make it more intuitive to use, improve its stability by fixing many bugs and also improve the UI to better fit the web app.
Purr Data a.k.a. Pd-l2ork 2 is an improved version of Miller Puckette’s Pd.
Pd (Pure Data) is a graphical data-flow programming environment which is geared towards real-time interactive computer music and multimedia applications. It is a full-featured open-source alternative to its commercial sibling, Cycling74’s Max.
Purr Data serves the same purpose, but offers a new and much improved graphical user interface and includes many 3rd party plug-ins. Like Pd, it runs on Linux, macOS, and Windows, and is open-source throughout.
The goal of this project is to make the Purr Data Web App more usable, stable, and reliable.
Qutip is a python package that presents a comprehensive toolbox to simulate the dynamics of open
quantum systems. Its core class is Qobj and it is used to represent a variety of Quantum objects such as kets or Hamiltonians, which has been improved in the last Google Summer of Code to extend its flexibility. It can now handle multiple representations of its data efficiently, for instance dense or sparse matrices. Here we propose to extend the implementation of this class allowing it to handle TensorFlow’s data type which will allow to store and manipulate the data of Qobj using a Graphical Processing Unit (GPU). In this way, QuTiP will be able to take advantage of the computing capabilities that the GPU offers.
The proposed project "Quple - Quantum GAN" serves as an extension to the 2020 GSoC project "Quple" with a major focus on the implementation of Quantum Generative Adversarial Networks (QGAN). In this proposal, the quantum version of various popular GAN algorithms such as deep convolutional GAN (DCGAN) and Wasserstein GAN (possibly with gradient penalty) will be developed. Various quantum data encoding methods and neural network structures such as hybrid quantum-classical layers and multi-quantum layers will be explored. Their performance will be evaluated based on real physical data from high energy physics experiments. The core components of QGAN will be based on the Google TensorFlow quantum library. Nevertheless, interfaces to common quantum computing libraries such as IBM Qiskit and Amazon Braket will be introduced to the framework to allow for more versatility and to cater to the need of users from different communities.
The main goal of this project is to make kw ready for it’s Beta release. The work is divided into two stages. The first one, corresponding to the period before the first evaluations, consists of varied tasks. It will serve the purpose of getting completely familiarized with the different parts of the program by working on bugs, documentation, tests, user interface and implementing important features for kernel development. The second stage consists of improving the efficiency of the most costly processes that kw supports: kernel build and deploy. It corresponds to the period between the two evaluations.
This project aims to unify the complete styling of the website using minimal space and complexity. Also, it aims to improve the designing of certain parts of the website to improve the User Interface. The project aims at delivering all the goals and deliverables as mentioned in the Project Idea List. It is made sure that the accessibility, design, and the interface is improved through the project. This project will not only provide a better user experience but also help in simplifying the codebase of CDLI. Finally ,it will be made sure that the designs and improvisations are responsive to mobile, tablet and all kind of browsers.
In the variable selection problem, various methods have been implemented using penalization. LASSO’s well-known method implements soft-thresholding with a constant threshold and SLOPE penalizes the regression problem with sorted L1-norm. SLOPE gives better FDR control and enables better handling of highly correlated predictors. The existing R package SLOPE is capable of performing both methods successfully. We aim to implement ABSLOPE, a recently developed SLOPE extension that combines the original SLOPE formulation with the spike and slab LASSO. The project results will contain an efficient version of the ABSLOPE algorithm for variable selection with high dimensional data and missing values.
Drogue Cloud supports the authentication of devices using X.509 certificates. Drg is the command-line client for Drogue cloud. This project aims to implement drg commands to work with certificates and keys to make the trust anchor workflow easier for the user.
Okular doesn't fully support stamp annotation representation resulting in sometimes rendering the same stamp icon couple times on the screen, or not being able to save custom stamps. This is due to Poppler, the backend rendering library, doesn't know how to save stamp icons or read standard stamp icons without AP streams. So, the scope of this project is to provide a way by which Poppler be able to render files with standard stamp icons without AP streams, as well as knowing how to save custom stamp images to a PDF files so other readers can render it as well. This will involve modifying the Qt wrapper as well, and modifying Okular so that it'll fully depend on Poppler's rendering other than rendering icons itself.
The sole aim of the project is to add web authentication support to XWiki which will allow the users of XWiki to authenticate themselves without having to type their username and password every time they try logging in. WebAuthn, a web authentication standard approved in March 2019 by the World Wide Web Consortium (W3C), makes it easy for websites, services, and applications to offer strong authentication without relying on passwords as it allows users to be authenticated using public-key cryptography. XWiki currently allows multiple ways of user authentication, and this project aims to provide one of the most secure ways of doing the same.
This project focuses on implementing an asynchronous mechanism for model inference and batch execution in the TensorFlow backend of the FFmpeg Deep Neural Network module to boost model inference performance.
The Tensorflow backend uses the TensorFlow C API, which currently does not provide functions for asynchronous execution. The support for async behavior can be provided using multithreading on the existing TensorFlow library functions. We will implement this behavior through detached threads that work independently of each other.
Several inference frames will be combined to a single input tensor and executed together in a single batch to enable the batch mode. The DNN module authors saw a performance gain in the OpenVino backend with asynchronous batch inference against synchronous inference. A similar performance gain is expected from this project.
Chrome browser and Chrome OS use Chrome Enterprise policies for added controls and configurations. Currently, some tests for policies are written in AutoTest. AutoTest is an old framework which can be updated with newer Tast framework written in Go. The proposed project aims to port some Power Management policies of Chrome OS from AutoTest framework to Tast framework, document them and make them stable. Tests will aim to test the behavior of the device under testing under different power conditions and verify its consistency with power policies.
In our work, we aim to research, implement and integrate a method that is capable of real-time manipulation of faces on mobile devices like changing the style of the hair, color of the lipstick or eyes, increasing the length of the hair, adding or removing facial hair, adding or removing smile and similar. We aim to be able to perform these kind of transformations while also preserving the identity of the input face and only changing local part of the input image of face while keeping other parts untouched.
The name Scala comes from the word scalable, and true to that name, the Scala language is used to power busy websites and analyze huge data sets. Scala is one of the leading languages in implementation of big data systems. It is widely used in streaming data. Similarly, Python has become the language of choice for data scientists with its many high-quality scientific libraries. ScalaPy is that bridge which gives an opportunity to use Python libraries in Scala. Last year a new version of Scala was introduced. At the moment it is not released but Scala 3 brings many new features and changes. The aim of this project is to discover those new features and implement support for ScalaPy in Scala 3. ScalaPy will possibly help Scala 3 to become more popular among scientists and maybe this will be the core moment in combining data processing and data analysis worlds in Scala 3.
In this project, I plan to create a full DSP block within the toolchain. Along with making it, I am going to test it from Verilog to Vivado through the model. The process of this transformation will follow from Verilog to Bitstream, then to recreate the original netlist for output bitstream and after this the model is tested through Vivado.
Updating and adding to Korean translations, as well as restructuring the Learn and Examples sections of the p5 website. Adding features such as a fixed navigation bar.
Continuing the work done on Rapid Annotator 2.0 by Vaibhav Gupta, There were some improvements and new functionalities can be added to the current project in order to make the rapid annotator more useful and easier to use. So, I decided to contribute with my ideas in order to make those improvements and impalement them.
This project aims to implement a special type of channel/room in Rocket Chat. The messages in this channel would vanish after a certain amount of time. In simple words, there would be a setting that decides after how much time messages would be deleted from the channel. Neither deleted messages can’t be retrieved back nor the feature can be deactivated once the channel has been created. The room would also vanish after its destruction time.
Exploration of the benefits of implementing layout manager in rust
The aim of this project is to augment the functionality of the Issues tab in Chrome Devtools by implementing Snooze, filter and search functionalities. These features will promote a better developer experience, clean the UI of the issues tab and improve the usability when the amount of added issues is high.
This proposal aims to bring scripting support to SwiftPM. The goal for GSoC is some kind of proof-of-concept and is expected to be the foundation of a full implementation of this feature. The outcome is expected to be a prototype of the new swift-script tool, which has a limited set of basic operations implemented like run and reset. There will also be a new flag for Swift Driver which enables a shortcut to the feature through swift command.
This project aims to Develop a Visual Recognition model for Aztec Hieroglyphs. Aztec language is pictographic and ideographic photo-writing. It has no alphabets but different symbolic signs. The model's working will be as follows it'll take in an image, compare it with the ones in our dataset, and finally display the possible matches of that image and identify various atomic elements in the picture. For training, we'll use Deep Neural Network model and, final deployment will be done on Heroku cloud server
The goal of the project is to develop a Domain Specific Language (DSL) that will enable users of the open source Home Assistant framework to program complex automation scenarios, for connected IoT devices, that go beyond simple automation rules. To make use of this DSL even easier for the end user, the language will be integrated in Node-RED’s flow-based low-code environment.
IIO Subsystem is the home of Linux sensors, it provides support to ADCs, DACs, Accelerometers, Temperature sensors, etc. IoT and industrial applications require sensors to monitor and control different things like motors and actuators. This project aims to implement a driver under the IIO Subsystem for Analog Devices, Inc.’s (ADI) ADXL355 Accelerometer, merge it upstream to the kernel tree, and exhibit a working example on Raspberry Pi 3B+.
The project aims to implement single-precision floating-point support for GPU acceleration in the VecGeom library. This will be achieved by first analyzing and locating the current errors, then fixing them for the most general cases. The process will be done for all primitive solids, starting with the most frequently used, and then for the global navigation algorithms.
Proposal for App: Bad-Words Filter. Rocket.Chat is Teams collaboration platform where people from different parts of world come together and collaborate. Some people can be toxic at times and can use harsh words against fellow members. This app can be helpful for Rocket.Chat platform for filtering bad-words.
Having seen the benefits of the open-source Rule-Based Machine Translation platform - Apertium as an alternative to other free/commercial online translator systems, especially for many low-resource language pairs, I decided to contribute to the platform by extending the list of language pairs my native language - Uzbek has so far. Being a master student in philology, and having some experience in the creation of language resources, I would like to propose to implement new language pair: Kazakh - Uzbek for Apertium, as these two languages are both low-resource Turkic languages that are official languages of two respective Central Asian countries with so many economical and cultural relationships. But this language pair still lacks an open-source machine translation system. My proposal is to fill this gap as much as possible during this GSoC2021 program. Since Uzbek and Kazakh languages from the same language family, they are closely related in terms of grammar, word order and similarity in vocabulary, so I will try to make a bidirectional translation, with a more focus on Kazakh -> Uzbek side, as Uzbek is my native language and I possess very basic knowledge in Kazakh.
Deepchem is one of the premier open-source deep learning libraries for chemistry. It is used by people worldwide, thus there is a need to develop and provide access to updated cutting-edge models, more metrics and tests for model performance evaluation and more recently developed loss functions. My GSoC ‘21 Project proposal is to add the Molecule Attention Transformer and a protein structure model to Deepchem and/or Jaxchem.
Implement Language Server for RBS
For this project, I would like to work with new models for random forests and gradient boosted trees. It would be interesting to then use this on a Kaggle competition and try to create materials to help students get started with these new models. Ideally, I would try to publish this on kaggle.com or tensorflow.org/tutorials in order to reach as large of an audience as possible.
Preventing phone scams by allowing users to assert the validity of unknown callers
One of the main limitations of Machine Learning models is the frameworks. Recent ML models use large tensors and require a lot of computing power as well as optimized algorithms for the neural network layers. Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. It serves as the backbone for Tensorflow and handles core matrix related operations with its highly optimized kernels. The objective of this project is to improve the performance and CUDA support as well as simplify Eigen’s integration with Tensorflow.
This project aims to introduce frontend routing in oppia using the angular router. This will replace the current backend routing system which uses more resources on both server and the client. After the completion of this project, users will be able to experience quick page changes and a better user experience overall. This project also involves migration from webpack to angular cli. Migration to angular cli will improve the overall development experience with its simplicity and code generation. The new developers starting up with oppia will find the codebase much easier to understand.
ODK-X Suitcase is a cross-platform tool that allows the user to upload, download, and update data on an ODK-X Cloud Endpoint from a personal computer . Users can either use the Graphical user interface or the command line interface to perform operations . Users can upload their data in CSV format and access them later. Data is uploaded in the Sync endpoint server. So , Sync endpoint server has to be configured to use the suitcase application. To upload the tables users have to arrange data in a particular form with a specified table_id . This table_id is used later to download the table . Currently, users need to enter the exact table_id which they want to download else the application would show an error message stating that table_id doesn't exist . In this project , this problem will be solved by providing the user a list of existing table_id so that it is not necessary to remember it . Users might also want to select more than one table_ids for downloading more than one table at once .To allow the users to download multiple tables users need to be provided the download options which could be different for every table or same for all tables.
New extension which allows user to pay membership fees through their local currency.
Tarantool's SQLite-derivative VM code for SQL engine known as 'vdbe' is creating a performance bottleneck: self-execution of the main part of the VM's opcode dispatcher is mostly half of total CPU time.
My proposal is to implement an embedded LLVM JIT engine solution which would replace part of vdbe responsible for DQL. In the future perspective, vdbe could be completely migrated to this engine. This solution is anticipated to give 20% performance boost for DQL compared to vdbe.
The goal of this project is to develop the solution described in the proposal, making it scalable, and integrate it with vdbe, afterwards benchmark it and compare its performance to that of original vdbe.
This project aims to realize a vhost-user-vsock application that will leverage the vhost-user protocol to emulate a virtio-vsock device in an external process. It will additionally provide the hybrid vsock over AF_UNIX interface, that was introduced by firecracker. Kata containers rely on virtio-vsock to create a communications channel between the runtime in the host and the agent in the guest. The vhost-user-vsock application, developed during the course of this program, would then be integrated into kata containers, who prefer that devices be emulated in an external userspace process to reduce the attack surface.
In the last decades, Bayesian statistics has gained ground in the modeling of phenomena. Despite its advantages, to implement a Bayesian framework is still difficult and restricted because the available literature on Bayesian statistics generally focuses on mathematical formalism and requires greater statistical expertise than some other methods. For this reason, any tool or resource that facilitates the understanding of Bayesian statistics and its mathematical background will be very useful. Turinj.jl is a high-performance probabilistic programming bayesian inference language inside Julia ecosystem. Inside Turing lang, MCMCChains.jl represents an implementation of Julia types for analyzing, storing and summarizing MCMC simulations and uses utility functions for diagnostics and results visualizations. This project comprises various tasks to improve different aspects of MCMCChains.jl such as plotting functionality and storage of MCMC sampling to achieve better heuristics.
We propose the implementation of Fast Fourier Transform (FFT) capabilities inside the Boost.Math library. This project answers the need for a C++ library of this sort, and the lack of FFT within Boost.Math. Our main goal is to design a modern C++ template interface for FFT that supports multiple types that satisfy the Ring Axioms and specialized routines for complex numbers, which constitute the most used cases.
One practical barrier for the usage of local network web-based applications (such as the LimeApp) in Android devices is that browsers don't allow the user to navigate local network resources when the network doesn't have a working gateway to the Internet, forcing the user to switch between mobile and wifi network to use local network resources and keep communicating over external services such as WhatsApp. The only way around this issue as of today is to develop a native android application that in fact can specify which network to use for fetching resources. We would like to develop a tiny native application to wrap web-based applications to accomplish this goal.
Security and Semantic bugs exist in software systems, and discovering them is time-consuming, complicated, and challenging.
Several static and dynamic techniques are presented for discovering bugs.
However, finding a bug is still a challenging topic.
In this work, we investigate developing a prototype tool that uses the benefits of using the lightweight specification, fuzzing, and symbolic execution for discovering security and semantic bugs in an arbitrary Java program.
This proposal aims to extend Badger, meaning both SPF and Kelinci, with the ability of handling both pre and postconditions using the runtime assertion checker of OpenJML with the lightweight specification.
Also, using and extending Debug.assume()'' andDebug.assert()'' mechanisms in SPF that they work like precondition and postcondition, respectively.
MuseScore is an open-source software that enables users to create and share professional-grade sheet music. The application really stands out as a great program in that it provides a hassle-free environment to create sheet music. Currently, the application uses styles defined in XML files to represent chords. Even though it greatly extends the functionality, it is not very accessible to an average user. This project aims at creating the Chord Symbol Style Editor for the users to have complete control over how the chords are represented in their sheet music. The editor houses a simple-to-use interface that provides the ability to control every aspect of the chord representation the user might want to customize.
Kworkflow is a kernel developer workflow tool with the simple mission of reducing the overhead with infrastructure setup for Linux development. In order to accomplish this goal, Kworkflow (or kw as it is commonly called by the community) must support a wide range of different setups. However, kw currently only supports two families of Linux distributions (Debian and Arch) and one bootloader(GRUB2). To help Kworkflow better accomplish its mission, the first half of this project will be dedicated to expanding support to some key bootloaders/bootmanager such as: U-boot (widely used by embedded systems and by ChromiumOS), rEFInd and the RaspberryPi bootloader. The second half of this project will build upon the work previously done by adding support to other Linux distributions, such as the RHET family and the ChromiumOS (through the newly supported U-boot).
The aim of this project is to create a module to import geometric data acquired from terrestrial laser scanners. It will focus on developing a method to directly model real objects and topographies without entering their geometries manually. The information gathered by the laser scanner in the form of ‘Point Cloud Data’ will be used to create a full 3D model of the object. The data from the 3D model is required to be mapped/converted/translated onto the Finite-Difference Time-Domain (FDTD) grid upon which gprMax is based.
RooFit is a C++ library for statistical data analysis and for modeling the expected distribution of observables measured in particle physics experiments. The pythonization work proposed here is vital to facilitate the transition from C++ to python to write analysis code. This project aims to simplify complex workflows and enhancement of the python interface, greatly reducing the amount of code that has to be written.
The objective of this project is to port BaseJump STL to FuseSoC so that new projects can directly reuse these hand-optimized IP cores rather than starting from scratch. BaseJump STL has the hardware primitives defined in the form of SystemVerilog modules. FuseSoC makes use of core files that reference the provider, file sets and default targets allowing for the reuse of IP cores in the process of creating, building and simulating SoC solutions. The major tasks involved in this project are creating cores for all the hardware models in BaseJump STL and porting the testing infrastructure.
LiveChat is a small and lightweight application designed to provide B2C communication between agents and website visitors. At present, Rocket.Chat’s LiveChat only allows users to chat in real-time with the agents. It does not have in-built support to allow video/audio calls. The aim of the project is to support video and audio calls using P2P webRTC architecture providing a frictionless experience for all the users(admin/manager/agent/visitor).
Inkscape is a vector editing software and svgs are a very important part of it. Currently inkscape offers many export options (to be precise “saving options”) but they are mostly limited to the whole document. Object related exports are mostly in raster format (that is .png or similar ). Being a vector editing software, SVG export option, if extended, for objects (that is Layers, Selection) can be a major boost in user experience.
Export options are an important part of any designing software. This proposal is to extend svg export to individual objects (selections, layers or groups, etc ) and modify UI of ‘Export As png’ dialog to ‘Export’ dialog which will provide more user friendly interaction for both ‘Export’ and ‘Batch Export’. This will also help ‘Batch Export’ gain more focus.
QGIS already has an integrated raster calculator, where user can enter an expression that will apply raster algebra functions to one or more input rasters and produce a new raster file. This project aim is to develop a raster calculator as a new renderer for raster layers. It will be possible to perform the computation on the fly when map gets rendered. It will be therefore possible for the users to see the results of raster algebra expression that has been typed without the creation of derived raster files. For example, it should be possible to compute the NDVI index on-the-fly. It's possible to take inspiration from already existing raster renderers such as hillsahding and contours, these two render type work in a similar way.
The work will be divided in two main big tasks, the first involves prototyping the new renderer, the second involves adding features for the user interface.
This project will focus on a current problem in the Hardware community: The speed of RTL Simulations. These types of simulations are a necessary step in any hardware design. It is intrinsically a hard problem, and even commercial simulators run slow compared to the real hardware, which can be several orders of magnitude faster. On the open-source side, Verilator is one of the most famous players and offers a competitive simulation speed time compared to the closed-source ones. We will base our work on this tool. This project will consider that modern processors rely on Network-On-Chip (NoC) to communicate several cores in the same chip. The idea would be to use this hardware partition into consideration and make a stand-alone simulation per core and communicate through OpenMPI. This could potentially enable the simulation of a 1000-core processor, something currently unmanageable.
To reason about string manipulating Java programs Symbolic Pathfinder (SPF) employs string constraint solvers. Currently, SPF integrates a limited set of dated string constraint solvers. Since string constraint solvers constantly evolve, there is a continuing need to integrate them with SPF. Adding a new string constraint solver into SPF involves augmentation to the existing SPF code. An in-depth understanding of the SPF solver interface is necessary to accomplish this integration. These obstacles lead to a lack of support for state-of-the-art string constraint solvers in SPF. This proposal outlines changes to SPF that would allow integration of Satisfiability Modulo Theories Library (SMT-LIB) compliant solvers with minimal effort and no modifications to existing code. Further, string constraint solvers that are not fully SMT-LIB compliant and require specific translations could be integrated with the addition of a single translation class and no modifications to existing code.
While pre-trained language models like GPT-2 provided with Transformers.jl can generate coherent text, controlling and steering of text towards the desired attribute is not directly possible with these pre-trained models as it is (particularly without fine-tuning). So the goal of this project to implement Plug and Play Language Model in Julia Language, which will facilitate the users working with Julia for NLP to generate Controllable text based on Transformers.jl package, which can be used in deployable Chatbots and further research in the field of Text Generation with Julia. Apart from the model, the final product of this project will also include an end-user interface to facilitate the integration of the PPLM model with few lines of code.
Some of the common applications of the model will include Sentiment Control and detoxification of the generated text.
In order to make DBpedia and its humongous linked data available to a larger user base in their natural languages, a Neural QA model has been developed to answer the question in English posed by users. This particular project aims to make our end-to-end system learn better compositionality of questions, by improving our current dataset and our learning model.
The project revolves around reducing the binary footprint of mlpack by replacing the functionality of boost::spirits to handle a more diverse range of data in mlpack. This project is a part of the bigger goal of removing boost dependencies. The project aims to re-implement mlpack’s custom CSV parser that is currently being utilized to handle non-numeric data by adaptive the armadillo's internal csv parser to handle non-numeric data.
Forecasting returns under range of investments can impact investment plans and financial goals as it can provide extensive empirical evidence, surveys of risk-based and behavioral theories, and practical insights. Guided by Antti Ilmanen’s work, this project will focus on improving project ExpectedReturns, including refactoring, applying FactorAnalytics packages into case studies, and adding unit tests.
Zulip Terminal is Zulip’s official terminal client, that provides a text-based user interface (TUI). I see Zulip Terminal potentially being a preferred client among many programming and open-source communities that use Zulip with heavy terminal users. I would work on improving the experience that Zulip Terminal provides. The primary objectives towards this goal would be to:
I also plan on refactoring other related code to cleaner forms, enhancing the testing suite by increasing the scope of the testing, fixing bugs that arise, and working on other miscellaneous issues and anything further that comes up.
This is a proposal for CodeLabz - FrontEnd Improvemnts idea (#22). This contains my personal information, my implementation idea, my SCoRe lab contribution and some mockup ui designs which I'm proposing. Furthermore , I have mentioned my qualifications including my Programming certificates, GitHub, and LinkedIn links in here.
The project will focus on getting end-to-end testing for the ReactNative repository fully implemented and running by the end. That encompasses making specific E2E variants for all the different flavours that E2E testing is desirable for, as are defined in the build.gradle file. Further on then, different features will be tested for the different variants too. Finally, the testing will have to be integrated into the Continuous Integration/Continuous Development pipelines, which is the main purpose of this project. This should help speed up code review times, and write tests side-by-side for android and iOS.
By using digital video, every day the number of people needs to edit and manipulate video content is to increase. This requires from us to have better understanding how videos are constructed. Videos are constructed by combining different shots of the camera placed after each other. A combination of different shot transition creates the final video at the end. The final video contain visual effects which could be classified into two main categories: sharp and gradual. The former is a sudden change of the shot over 1 frame, while gradual transitions occur over multiple frames. Gradual transitions are further classified into dissolve and non-dissolve. The former includes cases such as semi-transparent graduals, fade in and fade out. Non-dissolve are dominated by wipes. Wipe graduals have a much wider variety than the dissolve graduals.
Geopandas is one of the most popular Python projects for handling geographic problems and data. Whilst Geopandas is useful for handling small data problems, it does not scale well because its geometric computation is single-threaded. Therefore, advanced geospatial analysis is still dependent on the use of relational databases and spatial extensions such as postgreSQL/PostGIS. This project will extend Geopandas capabilities to handle big problems by using Dask to bridge this gap, allowing geometric computations to leverage all available CPU cores. This will be achieved by contributing to the dask-geopandas library, to enable distributing spatial indexing, related spatial partitioning and parallised IO. Additionally, we plan to integrate other spatial operations from Geopandas and basic plotting features.
Clang static analyzer was introduced to automatically find bugs at compile time by inspecting source code. While it is designed to be fast and lightweight, performance checks are necessary to rate it’s swiftness. The aim of this project is to figure the time spent in the transfer functions, obtaining more information by adding llvm’s statistics and timers, measuring stack frame’s time consumption and comparing custom and inlining methods.
Agent-based models (ABMs) are simulations in which autonomous entities (known as agents) react to their environment (which includes other agents) based on a predefined set of rules. The objective is to analyze the effect of agent behavior on the model as a whole. Agents.jl is a pure Julia library that assists with the creation of performant ABMs. It provides various tools and utilities to simulate complex agent-model behavior with little effort. My proposal is to add the following two features that are currently not present in Agents.jl:
The proposed project is to create voice channels giving users the ability create channels or join and leave pre-existing ones.
BIDS is a standard for neuroimaging datasets that helps with data sharing and reusability; as a result it has been widely adopted by the community. Although developed for MRI originally, it has gained popularity within the EEG and MEG realms. Converting raw data to the BIDS standard is not difficult but requires a lot of time if done by hand. Currently software like mne-bids and Biscuit are available to assist and facilitate this conversion but there is still no automated way to produce a valid BIDS dataset for the EEG and MEG use-cases. Mostly what is missing is metadata. Here a python package is proposed to be able to infer the missing information from files accompanying the EEG and MEG files and/or a single bids-conversion example provided by the user. The idea of having human-readable configuration files is also explored since this would help the sharing of common conversion parameters within similar communities. If this proposal was successfully implemented then batch conversion of BIDS datasets in the EEG and MEG cases would be realized. It is hoped that this package becomes the backend of an hypothetical web application that assists this conversion of MEG-EEG datasets.
This project involves fixing the last remaining kinks in the EvalAI UI. The goal of this project would be to improve the new UI as we replace the existing UI with the new UI. We will be improving on the new UI and incorporating the feedback we will receive from the challenge hosts and participants for the AI challenges organized this year.
Agora Vote has much scope of improvement to make the workflow of the app smoother. Instead of adding some major new features, my main goal for this summer is to make the app more optimised,stable,robust,efficient and to build the final production ready app and make it live on playstore to be used by various users around the world.
This project aims to work on two related problems. On one hand, I would like to implement new family of generalized linear models, such as beta regression, robust linear regression (i.e. linear model with error following a T-Student distribution) as well as multinomial regression. On the other hand, it is also necessary to incorporate more automatic prior distribution alternatives that do not make use of the GLM module in statsmodels so new models can work smoothly without requiring the user to manually specify priors.
A statistical suite to confirm that our Markov Chains produce results of the distributions we expect. These tests could be parametric or non-parametric distribution checks, but would also entail simply checking against an enumeration of all districting plans for small enough graphs. The test suite would be designed for automated/CI testing.
This project aims to package OpenWISP monitoring on OpenWRT. It focuses on creating a package from exisiting scripts adding some new features and getting it ready for first release.
A plugin will be created that includes a diff editor in order to make solving conflicts easier. Revisions data will also be used to create a new version of the note which has changes from conflicting devices merged. Then, the new note is shown by default in the diff window along with the old local note. Editing is allowed before submitting and saving.
rutorrent mobile interface is a project that started last year under the organisation CCExtractor Development and it's gone quite well, with the user base growing and a number of contributions being made by other developers. The aim of this project will be to improve the overall architecture of the project with improved and in detail documentation, multiple environments for testing, implement new features to the project and make a release of the app.
The Clang Static Analyzer currently has checkers for std::unique_ptr. These checkers are currently in the experimental (alpha) group of checkers. I intend to complete the unique_ptr checker so that it can be included in the default list of checkers and be enabled by default. In addition, I would like to add a checker for std::shared_ptr and std::weak_ptr, which would be an alpha checker.
Proposals about Kiwix-android
Currently, there is no standard platform where users can report bugs when they are working with Nominatim. Generally, if a user wants to report a bug, he/she needs to go to the GitHub repository and then report the bug. But the problem here is that user’s who aren’t programmers and who don’t have Github accounts find it tedious and challenging to report bugs.
This project aims at setting up a separate interface where users can interact and report bugs in a hassle-free way. The reports generated will be stored in a log file. Reports can also be regenerated or tested by running a script that will export the log file to CSV files, which Geocode Tester can process.
Skyhook Data Management is programmable storage for databases. Every software needs documentation that is easily accessible and easy to use/refer to. Being Open Source means that developers from anywhere are welcome to contribute. Strong and easy-to-use documentation encourages developers to start contributing right away. The current documentation is hosted on GitHub wiki, which is not very intuitive to use. We want to port the documentation to Arrow’s ReadTheDocs to have a better user experience and interface. There are some sections that might need some revising to make it better. The documentation structure also would need to be reorganized in light of the migration. The documentation also needs to be in line with the Arrow documentation since we want to upstream it.
A complete predictive text input solution for xrdesktop. It is an aggregation of three input modes: Dasher, Swype and a normal virtual keyboard. Combined, they form a VR input system that is highly effective for experienced users, but also usable for first-time users.
As described on the idea page “Currently language detection is rudimentary and often causes incorrect interpretation of dates.” Implementing an optional language detection library to improve language detection. In the last four weeks (6th to 9th week) if the above task is completed, fixing as much as possible the issues with the search_dates function. Currently, there are over 27 open issues.
PROJECT GOALS
GSoC Proposal: Multi-Start Optimization Methods
The Proposal contains details for implementation of Socket Module with basic implementation for HTTP Server Module to be completed within the timeline of GSOC in summers. Key elements of the proposal are:
VisualCircuit allows users to program robotic intelligence using a visual language which consists of blocks and wires, similar to electronic circuits. Currently it's a desktop application released for Linux based on IceStudio which uses AngularJS. The aim of this project is to make a similar web application so that users do not have to do any installation and use newer frameworks on the front-end since EOL for AngularJS is in December 2021. The requirements of the project are:
libavutil is being expanded with a modern way of handling frequency transformation. The project aims to significantly increase the speed of this code on a selected architecture by writing the transformations in assembly.
This project aims to continue on the development of the Musicbrainz Android App further and complete the tagger implementation, revamp the UI to beautify the results, work on documenting the Code, Design, GitHub repository and all the implementations in the best manner possible while moving the codebase to Kotlin completely.
There is a deep learning module in OpenCV named DNN, which has a set of built-in layers and functionality for loading serialized networks models from different frameworks. There are many matrix multiples and add operation in many layers, such as the convolution layer. These operations can be optimized by SIMD and some convolution operation optimizations have been optimized in layers_common.simd.hpp with AVX intrinsics. RISC-V vector extension also have many useful intrinsics to optimize deep learning kernels. I believe that we can imitate it to implement the optimized code with RVV Intrinsic by following way: First, Create a code block wrapped by the macro "CV_RVV" which can help us distinguishing the implementation of optimize OpenCV DNN on different platforms. Secondly, use RISC-V V intrinsics instead of AVX intrinsics but keep the function unchanged. Finally, test the code using QEMU.
MusicBrainz has client libraries for various programming languages such as C++, Python, Java, Go and more. However, we're still missing out on a proper client library for the Rust programming language. There previously have been attempts on creating such a client library, such as the musicbrainz_rust (not being maintained at the moment) and the musicbrainz_rs projects, but none of these attempts entirely wrap around the MusicBrainz Web-API.
As a part of GSoC'21, I propose to implement further functionality in musicbrainz_rs, a Rust client library which has proper automated tests and has been carefully documented along with examples. However, it still misses out on covering some important functionality from the Web-API, namely the Search feature and the CoverArt endpoint. There are also further possible improvements that could be made, such as gracefully handling rate-limiting from the MusicBrainz servers by performing auto-retries on failed queries in the library.
MinPlatform is a project to get open-source EDK2 firmware booting mainstream boards. However, other than the Intel RVP development boards, presently it only supports the UP Xtreme and System76 Galago Pro 3 (discontinued).
Therefore, I propose to develop a board port to an Acer Skylake platform. This adds another board port to the tree, resulting in open-source firmware being a little more widely available. I also hope that it encourages further work in this area.
This project seems to implement the asymmetric traveling salesman problem developed by Asadpour et al, originally published in 2010 and revised in 2017. The project is broken into multiple methods, each of which has a set timetable during the project. We start by solving the Held-Karp relaxation by developing a solver for the ellipsoid method (I tried to use SciPy and the results are discussed in the application). From here the algorithm is followed as outlined in the research paper. We approximate the distribution of spanning trees using a maximum entropy rounding method to construct an undirected spanning tree with special properties which can be converted into a directed tree, augmented and shortcut down to an O(log n / log log n) approximation of the minimum Hamiltonian cycle.
I did not realize that this application process supported drafts, otherwise I would have used them.
The idea is to build a sample diagnostics tool for ChromeOS using web technologies. This tool will be a combination of a Progressive Web App and a chrome extension that help users monitor and diagnose their devices. The aim of this app is to provide OEMs an example of how to develop diagnostic apps for ChromeOS. As a result, a new API surface will be usable for other 3rd party apps to use and integrate on ChromeOS. In the later stages, the project aims to use WebAssembly for processing and storing system data captured from the underlying platform.
ArviZ is a python package for exploratory analysis of Bayesian models. While being agnostic about the inference tools, it includes the functions for posterior analysis, data storage, sample diagnostics, model checking, and comparison. More often than not, users working in the Bayesian inference space deal with large data. Even though ArviZ provides a very efficient solution, it doesn't scale well when it comes to larger-than-memory datasets. Deeper integration with Dask will allow ArviZ's methods to scale better when dealing with large datasets, whether the computation is running on a single laptop or clusters of machines. Therefore, this project aims to extend the current Dask support by targeting the loose ends in stats and diagnostic modules and adding dask support to the data module.
Camera imaging pipeline is typically embedded in a camera hardware making it difficult to customize the imaging algorithm for developers.The project is aimed to develop a software camera pipeline within the libcamera framework, which also includes the GPU/SIMD acceleration.
Systems Biology Markup Language (SBML) is a standard format for the representation and exchange of biological models between computers. The information in an SBML model file is organized as a list of components encapsulated within the model (e.g. compartments, species, parameters, reactions, etc.). However, SBML is difficult to read, comprehend and interpret by humans directly, and tools are required to provide an abstraction layer to interact with SBML objects and the relationships between them. The objective of the project SBML4Humans is to address this issue by providing an interactive and reactive report for SBML models which will allow humans (experts as well as beginners) to easily comprehend the content of a model. The key features introduced in the interactive report are:
i) interactive SBML report with navigation between SBML objects
ii) search and filter functionality
iii) web application with REST API
iv) downloadable standalone reports
v) support for hierarchical models
vi) support for distributions and uncertainties
vii) support for COMBINE archives
Such an interactive report will thus significantly enhance the process of reading and exchanging SBML models.
The project's main objective is to create a remaining web interface for the Retroshare using JSON API, mithril, HTML and CSS.
The Compact Muon Solenoid (CMS) experiment is one of the largest experiments at Large Hadron Collider (LHC) that has been built to search for new physics. CMS Software (CMSSW) is the framework utilized by the CMS experiment for Data Acquisition, Trigger and Event Reconstruction. The future upgrade of the LHC will add new challenges for CMS detector due to the larger amount of data that will be produced. One solution is to look towards a heterogeneous High-Level Trigger (HLT) Computing Farm, where the computing load can be distributed among different hardware (CPU, GPU, FPGAS). This project aims to use Portability Libraries like Alpaka to write code for the CMS Software (CMSSW), in order to have a single implementation which will be compiled on different architectures. In the last years, a new pixel track reconstruction that can run on GPUs (CUDA) has been implemented. The goals are to port the current CUDA implementation with Alpaka, in order to understand if this library is feasible for CMSSW and to compare the timing performances between Alpaka implementation and native CUDA.
DiffEqSensitivity.jl is a Julia package within the SciML ecosystem for computing (adjoint) sensitivities for various kinds of differential equations in a highly performant manner within a unified user interface. In this project, we aim at implementing continuous adjoint sensitivity methods for hybrid differential equations as well as shadowing methods for chaotic dynamical systems in the DiffEqSensitivity.jl package. Moreover, we will add a symbolic preprocessing option based on the ModelingToolkit.jl package to build highly optimized adjoint differential equation code in DiffEqSensitivity.jl. Finally, we plan to refactor DiffEqSensitivity.jl to make use of a new package, namely AbstractDifferentiation.jl, such that users may straightforwardly select the best performing automatic-differentiation backend in each part of their program without the need to adapt their code substantially.
Possible fields of application for these tools range from model discovery with explicit dosing times in pharmacology, over accurate gradient estimates for chaotic fluid dynamics, to the control of open quantum systems.
ndcube is a package that lets users combine multi-dimensional astronomical data with their corresponding real-world physical coordinates. WCS transformations are used to make this conversion. ndcube provides a powerful technique to couple them together so that researchers can tinker with their data while being assured that the underlying transformations remain consistent with any operations they perform.
This project aims to add support for resampling n-dimensional data. Essentially, it means that users will be able to upsample or downsample the resolution of their data based on their specific needs. They will be able to map it on a different grid that better suits their research requirements. Just like with existing operations such as slicing, this project will ensure that resampling an NDCube will modify the underlying WCS transformations and other attached parameters, to make it always remain consistent with the data.
One key part in ensuring a development team reaches optimal efficiency is by ensuring there are reasonable checks in place to avoid regressing previous fixes, reducing trivial verification during code reviews, and ensuring that team members are utilizing best practices. Oppia-Android already has the static analysis tools present, but there are still numerous essential static analysis checks which the project currently lacks. The default behavior of these linting tools is not enough to meet all the best practices. This project aims to add all those essential static analysis checks which the project currently lacks so that the development team reaches optimal efficiency
FOSSology is designed in modular fashion but it certainly does not follow micro-service architecture. FOSSology is capable enough to run in a cluster mode. It can connect to other nodes in a cluster over SSH and execute agents. But it is not very flexible.
Create Java library that implements the FHIRPath specification and write documentation that explains how this library can be used. This is important for healthcare interoperability, as it is necessary to have fast navigation, selection and formulation of invariants in both Fast Healthcare Interoperability resources and HL7 Clinical Query language.
This project aims to take a step towards a solution, which could make LibreOffice able to handle proper table styles. Implementing table styles in Writer is an ongoing effort for a long time now. However, some major steps are already done, like implementing the table style support in the Writer model, or implementing the ODF import and export filters, there is still a lot of work to be done. This project would aim to do the DOCX import part of it.
The problem with the current import is that table styles found in DOCX documents are converted into direct formatting at the level of Writer core. This temporarly solution works fine until someone wants to edit the table, which can cause loss of formatting now. Furthermore, doing this conversion upon opening a DOCX document is very slow.
The aim of my project would be implementing the DOCX import of table styles and removing the current style-based formatting conversion to direct formatting. This task may cause the need of extending the existing table style features in Writer. For example, an important, not yet supported property is style inheritance.
Add webview components UI
Versatile Video Coding (VVC) is the latest video compression standard after HEVC. GStreamer need to support VVC, and we should start from a VVC parser. Codec parsers are a core part of the Gstreamer hardware decoder. They are used in gstvappi and gstcodecs to split frames, get slice level information. VVC specification is finalized on 6 July 2021. It's a good time to start work on the VVC codec parser for GStreamer.
The CrawlerX is a platform which we can use for crawling web URLs in different kinds of protocols in a distributed way. This proposal mainly focuses on deploying the CrawlerX web platform on Kubernetes with best practices and new techniques.
The goal of this project is to implement a frontend environment for Administrators and Content Creators/Consumers of the Sastix CMS and extend the current capabilities to support the frontend client and the monitoring of the application. The provided solution will support multirole access and authorization, simple, secure flows and scalable deployment through docker and kubernetes.
DeepChem has enabled powerful and practical applications for machine learning in many disciplines of the natural sciences. While its name recognizes its historical origins as a tool for analyzing chemical molecules, its reach has more recently broadened to encompass neighboring fields such as materials science and biology. The goal of this proposal is to expand DeepChem’s burgeoning infrastructure to better support protein modeling.
This proposal will add a simple codon featurizer to DeepChem, which will be the first DeepChem featurizer capable of directly processing RNAs and protein sequences.
It will also add new model classes to DeepChem’s models directory. These classes will act as wrappers for models in Facebook’s Evolutionary Scale Modeling (ESM) repository. They will enable DeepChem users to use ESM’s Multiple Sequence Alignment transformer and Protein BERT models to perform efficient, scalable transformer learning.
Also including carefully planned additions to DeepChem’s documentation, unit tests, tutorials, and the MoleculeNet benchmarking suite, this proposal will empower DeepChem users to perform large scale protein modeling while staying within our ecosystem.
Currently, Rizin is able to load segments and sections as well as fetch all symbols and relocations and extract everything we need to analyse the binary. However, those features are biased. Indeed, during the loading of the new binary, Rizin uses various information that aren't relevant as default loading data. For example, Rizin loads sections information at the start. But it is common knowledge that section information can be manipulated without modifying the program execution. With this issue comes the fact that Rizin uses section information to deduct imported functions, strings and for other various analyses. Therefore, we need to make the section loading optional. The second problem is how Rizin loads PLT data. Currently, the PLT is linked to the GOT using hard coded values, which should be replaced by a dynamic analysis like in Ghidra.
Dhall is a programmable configuration language that uses functions, types and imports to make readable configuration files easily. Right now, Dhall has tools for converting to and from other configuration formats like JSON and YAML.
However, Dhall does not currently support a TOML binding and it would be very helpful to have a tool that converts bidirectionally between Dhall configuration files and TOML files. The aim of this project is implement said tool to convert bidirectionally between Dhall and TOML configuration language
Bookbrainz lacks a feature which allows a person to create a series entity. A series is a sequence of separate author, work, edition or edition-group with a common theme. The individual entities will often have been given a number indicating their position in the series.
DBNQA is a large database that can be used to create question answering models. Using a question answering model like NSPM, we can create and experiment with various kinds of QA models with DBNQA. But as we create more and more models it’s become more complicated to manage and use these models. To overcome a situation like this, it’s mandatory to maintain an AI lifecycle management mechanism. This project is trying to address this problem by designing and implementing a lifecycle management framework for DBpedia Neural Question Answering Models.
The project aims to make GCC's static analysis pass ( -fanalyzer option ) understand dynamic dispatch ( virtual functions ) in C++.
This project will greatly benefit people who like me use static analysis pass to analyse their C++ programs for various problems at compile-time rather than spending a lot more time finding them at runtime, making the overall debugging process of any C++ project much faster and easier.
Develop a simple app with basic features using the FHIR SDK for other groups to build upon.
My project aims to define a new similarity measure metric based on social coding semantics underlying the open source trace data to enrich the ability of Augur. The heterogeneous information network schema and network embedding techniques are introduced to capture the latent similarity information between repositories. This project will end up with some new computational models to transform those information into computable representation vectors with respect to every repository.
This project aims to add runtime pluggability to the Reva framework to enhance developer experience at AARNet, ownCloud and CERN. This would involve:
This project would help developers at oCIS/CERN to add plugin drivers to Reva in a much faster and hassle-free manner.
Backend for the Beacon project, with a focus on scalability and real-time low latency location synchronization.
ArviZ is a Python package for exploratory analysis of Bayesian models, intending to provide backend-agnostic tools for diagnostics and visualizations of Bayesian inference in Python. There are currently no specific plots in arviz to visualize time series or regression models. My proposal is to add time series plots including line and scatter plots to the library to visualize the uncertainty in the actual data vs range of predicted data. Dataset is assumed to be provided by the user. Project includes the documentation of functions implemented and examples for each of them.
Hello MoveIt maintainers and potential mentors! I am Captain Yoshi and this summer will be the beginning of my first year as a PhD student with the IntroLab group at the University of Sherbrooke in Canada. Personally, I would extend the benchmark package so that it could be used by the Benchmark Suite and also by everyone who wants to do benchmarks. Additionally, the trajectories should also be kept so that someone could visualize the trajectory. The seed used in sampling based planners should also be kept. This could be used directly to compare two collision detection algorithms and also for benchmarking CHOMP as a post-processor. We could also do benchmarks on different mesh qualities. For example, Tesseract has the ability to reduce a mesh complexity. I think MTC could be used to setup benchmark easily by adding the desired scenes, start pose and end goal or path constraints in the database in one click.
Grimoirelab is an open-source toolset for software development analytics. Grimoirelab provides a set of tools to collect, analyze and visualize software development metrics from a variety of sources like Git, Jira, Confluence, Slack, etc. In order to manage the identities of people across these different sources, Grimoirelab developed Sorting Hat. Sorting Hat manages the identities of people and related metadata.
As part of the metadata collected around identities, Sorting Hat stores organizational information such as the name and domains related to the organization. This project aims to add to this information by extending the existing Organization model to capture the internal structure of organizations such as departments, sub-organizations, and teams. This will help in annotating the identity information more meaningfully.
Cytoscape is a highly popular open source bioinformatics software platform for visualizing, analyzing, and publishing graphs or networks representing molecular interactions, gene expression, and other biological data. As a desktop platform, Cytoscape is one of the most successful open source projects in biology, and it is capable of integrating observational data from numerous sources.
Currently, when users are working with a network of connected genes or proteins, they have to use external web tools to perform simple enrichment analyses, e.g., using g:Profiler. However, g:Profiler provides a web service interface, so it would be relatively simple to provide access to this same service from within Cytoscape. More advanced tools for enrichment already exist as Cytoscape apps, such as BiNGO and ClueGO. The goal to produce an app that could eventually be included in the core distribution of Cytoscape.
Because of the recent sharp growth of the satellite industry, it is necessary to have free, accessible, open-source software to analyze satellite signals and track them. In order to achieve that, as one of the most essential steps, those applications must calculate the exact centers of the input satellite signals in the frequency domain. My project is initiated to accommodate this requirement. It aims to provide a program that can reliably detect satellite signals and find their exact frequency centers with high precision, thus providing important statistics for signal analyzing and satellite tracking.
Riemann surfaces are key objects in many areas of maths, from mathematical physics to algebraic and arithmetic geometry. As such there is considerable interest in implementing computational methods to understand these objects, with packages with various levels of utility and accuracy exists in multiple Computer Algebra Systems (CASs), and a meeting with active members of the community demonstrated an appetite and need for a centralised CAS with which to complete calculations. Sage is, we believe, the best candidate. This project would then build upon the existing work of Nils Bruin to implement and improve the necessary backend tools for such a system, before proceeding to utilise these to create a method for the Abel-Jacobi map, an important object in the study of Riemann surfaces.
DNSTool is a system to monitor a given set of internet resources such as Domains, IPs, etc. The DNSTool Middleware/API is the main component that manages the core processing and obtaining of scan lists and their respective scan results. DNSTool Middleware/API acts as a bridge between the user interface and the back-end system.
enviroCar is a Citizen Science tool that is used by citizens, traffic planners, scientists and companies to collect and analyze vehicle information in various traffic situations and gain insight to support the development of sustainable traffic concepts.
The enviroCar Android App connects with a car's onboard sensors via OBD-II and records the sensors data to generate real-time information like vehicle speed, revolutions per minute and calculates additional information, such as fuel consumption, estimated fuel cost and CO2 emissions. The only limitation being that it is only available for Android users.
This summer I will be working closely with the community and mentors of 52°North to lay the foundation of a platform independent enviroCar app to allow iOS users to access the amazing features of enviroCar.
Devolearn was developed during Google Summer of Code 2020, and is now a python library released on PyPI. DevoLearn contains pre-trained Deep Learning models for the segmentation/analysis of microscopy images. It is specialized for the analysis of 2-D slices of C. elegans embryogenesis, however it can also be useful in the analysis of embryogenesis in other species.The top priorities of this proposal are:
Using images in the content of a website is incredibly necessary to help the users interact and feel at ease on the website. But what’s much more critical is to optimize the images used in the content by correctly sizing them for different screens and not to use more than necessary. Unoptimized photos, instead, can increase the website's load time unnecessarily and drive users away.
On the other hand, various media types must be used in different situations in web content. So, users should be able to upload any media type they want and perform the required operations on it before publishing it on the site.
Goals of this project:
• Creating a high-accuracy morphological analyser for Ibo by contributing to the currently existing one; • Increasing WER on the eng-ibo pair (goal: below 30%); • Increasing naïve coverage of the eng-ibo pair (goal of up to 90%)
Robust statistics are useful in finance since all classical estimates are vulnerable to extreme distortion by outliers. Because financial data has outliers to various degrees, practitioners need robust estimates that:
PerformanceAnalytics is a collection of econometric functions for performance and risk analysis, long considered a core package by the finance community. In addition to standard risk and performance metrics, this package aims to assist practitioners and researchers in using the latest research in the analysis of non-normal return streams.
The idea here is to supplement existing functions in PerformanceAnalytics for calculating betas with robust betas fit using a modern robust regression method
The current web application of OWTF has no login/signup implementation. Through this project, I want to work on developing the login and signup components using React with Redux for state management. I will also work on implementing a set of full-fledged robust API endpoints for serving these login/signup-related requests. As part of this project, I will also like to add OAuth authentication using Google, GitHub, and Twitter. Finally, I will write unit/functional tests to guarantee the proper working of each component ensuring the complete module is foolproof.
Pallene is a statically typed sister of the Lua programming language. This proposal aims to add support for Closures in Pallene.
Closures are functions that are capable of capturing variables from outer scopes and retain references to them even after their scope has been exited. The addition of closures and higher order functions will allow programmers to take a functional approach when authoring libraries and scripts.
The scalable , extendable backend services stress tester.
This project aims at firstly, investigating the performance of the current implementations against its alternatives at various levels of data transfer over the network connection for Duet, and further integrating the improvements into the PySyft stack.
This project idea aims to develop from scratch a web application that collects a number of useful characteristics about popular linux distribution software packages, stores them in a database and provides an intuitive user interface. In this way, a user can conveniently query the database information in a read-only way, by setting specific searching criteria. The project consists of 3 different parts: the database that will be populated with the packages’ information, the back-end that is responsible for appropriately querying the database and feeding the front-end with the corresponding results and lastly the front-end, the purpose of which is to provide search filters and present the packages’ information in a well structured way, aiming to a pleasant user experience. The application focuses on the ease of installation and use. The biggest benefit to the community will probably be the easy and direct access to the source code of the packages, via links to the Software Heritage archive; which is extremely useful for new package builds on top of existing ones.
The Toolkit for Multivariate Data Analysis with ROOT (TMVA) provides a machine learning environment for the processing and evaluation of multivariate classification, both binary and multi-class, and regression techniques targeting applications in high-energy physics. The latest development in TMVA is a fast interference system, with its own intermediate representation of the deep learning model compliant with the ONNX standard. With this new inference system, TMVA aims to provide convenience for users in High Energy Physics in the deployment of their Deep Learning models in a production environment. To facilitate the usage, storage and exchange of these models,this project aims to develop the storage functionality of Deep Learning models in the ROOT format, popular in the High Energy Physics community.
DNSTool is a project that serves the purpose of rapid monitoring of DNS traffic over time. This system allows its users to create their seed lists for DNS monitoring or add given seed lists to their watch lists. DNSTool also allows its users to control the DNS resolution scopes over global scan endpoints. DNSTool-CLI is an extension of the DNSTool, which is designed to monitor the given set of internet resources like domains, IP, SOA, etc. This component allows the downloading of the DNS scan feed(s) automatically by integrating the CLI to their corn jobs or Airflow automation. This project is to develop high throughput and low latency data transferring pipeline with authentication for transferring the data from the system’s file store to the consumer environment.
The objective of the project is to provide support for Dumping the shared memory region in user-mode (unprivileged-mode) in CRIU
CodeMirror 6 is an editor which supports many programming languages. However, it lacks first-class language support for Haskell. The Abstract Syntax Tree is missing, because a compatibility shim is used, instead of a proper parser. Also, there are several problems with recovering from source code errors.
The idea of this project is to add first-class Haskell language support. The primary objective is to ensure full functionality, having any syntactic or semantic error detected and handled. Another aim is to make the code as modular as possible, such that it would be easily extended.
The TumorComparer is a computational method for the comparison of different cancer types with cancer cell lines by their cellular profile. This comparison allows finding the closest cell lines for a selected cancer type by molecular profile as well as to detect outliers.
The main objectives of the project are:
Further updates for the package are:
Finally, an updated version of the package will be capable to analyze new omics data types as well as perform comparisons for separate gene sets. R shiny application will be more optimized and user-friendly.
This project should broaden the functionality of being able to specify flags for compilation profiles, which is so far quite limited. It should also allow the support of different argument types. Therefore the user should be able to specify project local arguments, which are not overwritten by main package arguments when a project is used as a dependency and also argument types, which are applicable for the whole project.
In Most of the medical producers like surgery or in interventional radiology, the procedures are recorded as video. Common artefacts observed in them are anatomical structures like organs and tissue. Apart from these there is patient data present as overlay. Using deep learning we can add labels to the data in order to predict the nature of these anatomical structures By adding a deep learning anatomical structure classification pipeline to a VR environment would help training of apprentices much better than present ways.
Build utilities for Postman entities
Polypheny currently provides a SQL and REST interface for querying data. However many queries in SQL are very complex. The code for the same would be very verbose. This is something that can very easily be solved by CQL as it is very concise. The difficulty in SQL is because SQL has no knowledge of the context however CQL does (new contexts can be created). CQL has advantages in being a very expressive language. Users can create their own context sets (which can contain various indices, relations and relation modifiers). This is much more powerful than SQL that only supports existing relation modifiers.
LabelLab is an image labeling and classification tool for researchers. Currently, the mobile application supports labeling images on the fly in addition to managing projects and running classifications. The goal for this year's GSOC is to improve the team management and collaboration experience in the mobile application, along with fixing existing bugs and improving the documentation.
Proposal for integrating Out of Office Settings into the Rocket.Chat codebase.
The Apache Synapse ESB currently exists as a standard server runtime, the same state it’s been since inception. However cloud native technologies have in the meantime advanced significantly and concepts such as containerisation have been introduced. Containerisation brings with it several benefits such as portability, scalability, faster deployment & increased security.
This project aims to containerise Apache Synapse while not being detrimental to its current features and capabilities.
Fuzzing has been a popular vulnerability detection tool, and researchers have developed various techniques to build the "best" fuzzer. It is claimed, however, that the fuzzer adjusted for the target program that one wants to fuzz is the most effective one.
LibAFL offers those functionalities, with which users can customize the fuzzer or even extend the fuzzer tailored for each target program. However, since it is still at the early stage of development, some of the powerful scheduling algorithms have not been incorporated into LibAFL yet.
This proposal is to implement two effective scheduling algorithms, the AFLFast, and the MOpt algorithm into LibAFL. With these techniques, LibAFL can offer users a faster way to discover vulnerabilities and a more efficient mutator selection strategy.
Many genes both within and across species share a common origin. Homologoy inference is concerned with disentangling the precise nature of this shared origin and is essential for performing comparative genomics studies between species where previously unseen genes are annotated by comparing protein sequences to those of a known species. Inferring such relationships is can be computationally expensive. Deep learning offers a way to infer homolgy relations based on a limited set of data. This project will build upon previous work to develop a faster pre-processing pipeline and boost predictive performance for more distantly related species.
NetworkX has a wide variety of algorithms implemented. Although the algorithms are well documented, explanations of the ideas behind the algorithms are often lacking.
The goal of this project is to create Jupyter notebooks that will become detailed and intuitive tutorials containing the ideas behind algorithms, explanations of the algorithms, and experimental analysis of these algorithms.
In this project, I will study WebGPU, the upcoming standard for exposing the capabilities of the GPU hardware in web browsers, and its shading language WGSL. I will then try to test WGSL, by using a mutation based approach. Designing custom mutators can be done by either using the bijection between SPIR-V and WGSL and the existing spirv-fuzz tools, or by studying WGSL in isolation and generating new LibFuzzer custom mutators that operate on WGSL directly or in the output generated by Tint, which is a compiler for WGSL.
DNSTool WebApplication is the main access portal of the DNSTool which is designed to monitor the given set of internet resources like domains, IP, SOA, etc. Frontend allows users to upload their scanning seed list(s) and control the scans as well as schedule them. This project is to design a responsive and user-friendly single-page application as the frontend (dashboard).
Jump processes are a fundamental component in stochastic models throughout engineering, medicine and the sciences. DiffEqJump is a part of SciML, which contains infrastructure to stochastically simulate jump networks. While simulation algorithms for spatially non-homogeneous systems exist in academic literature, they are not currently supported in DiffEqJump. The goal of this project is to expand DiffEqJump with new, optimized spatial solvers and a consistent interface, enabling the study of large spatial systems of jump processes and the use of jump processes within other SciML tooling.
An approach to enhance the functionality of the MIT App Inventor by adding support for Custom Font Typeface that enhances the flexibility of user-interface design.
On Windows, using the Clang toolchain still depends on Visual Studio. This proposal is to fix these two dependencies: a. BaseTools contains C programs that need to be compiled and executed as part of the build process. While we have gotten Clang to compile UEFI modules, we have not gotten it to compile windows .exe files yet. b. BaseTools currently depends on the nmake.exe program included with Visual Studio, but it also supports GNU make for UNIX systems. A method of building and distributing a Windows version of GNU make needs to be made and BaseTools needs to be adjusted to use it.
PostgreSQL is a big and active open-source DBMS. This means that the code changes frequently and there are a lot of branches and commits. When big changes are made, performance has to be tested.
Performance Farm is a program that can be used to collect and visualize the benchmark results while the source code changes. Developers can analyze the performance of different versions of the source code or the efficacy on different operating systems.
It is built with Python scripts, a Django API, and a Vue front-end website. The actual benchmarks can be run on Linux and macOS machines while the users can easily see the results using the website.
This project aims to improve Performance Farm by adding system metadata, removing dependencies, and improving the website GUI.
The goal of the project is to develop and test a suite of ready-to-run benchmarks to measure the performances of various partitioning options on industry grade GPUs while performing the baseline performance measurements that are necessary to test the solutions developed within OpenForBC.
This project will be focused on the control and monitoring of plant pests and diseases. Especially focused on agriculture, for the detection and geolocation of these infections, and avoid their spread.
The objective will be to create a device for manual use that, through a photographic system, will be able to examine the leaves of the plants looking for any defects caused by these diseases.
The device will use an AI programmed to compare miles of photos of plant leaves with their various defects and will give the result of the health evaluation.
This data could be reflected by different types of LED’s through the device or by an application that could provide more information.
These results will be processed and sent to a geographic platform to locate the infected plants in the territory with the purpose of quickly combating these pests with the least possible waste. This will be compatible with liquid galaxy technology for a better interaction and visualization of the contaminated terrain.
Freifunk Digital Twin - test on your virtual mesh before going productive
TensorFlow Lite Task Library examples for Natural Language Processing is a project, where we have to recreate existing NLP examples in Android & IOS using the new TensorFlow Lite Task Library. There are three existing NLP examples: Bert QnA, Smart Reply and Text Classification.
Bert QnA examples use Tensorflow Lite Support Library, so it requires a lot of extra code such as data conversion, pre/post processing, loading associated files. So we’ll recreate it using Task Library in Android and IOS both.
Like Bert QnA examples, Smart Reply example also uses Tensorflow Lite Support Library, so it requires a lot of extra code and also there’s IOS example for Smart Reply. So we’ll recreate the Android Example using Task Library, and create the IOS example for the first time using Task Library.
Unlike Bert QnA examples and Smart Reply, Text Classification uses Tensorflow Lite Task Library, and also can switch between both support and Task Library in the android example.
Calibrate SDR+ is an enhanced version of Calibrate SDR by AerospaceResearch.net with the additional support of GSM, ATSC, and DVB-T signals for correcting frequency offset that occurred during SDR operation. Calibrate SDR+ would provide calibration to the SDR community all around the world if these signals exist there.
more on Calibrate SDR blog by Andreas Hornig (my mentor)
Real-world data generating processes often don't produce normally-distributed data, in particular the skewness/kurtosis/tail index parameters are inconsistent with a Gaussian random variable. If we can "Gaussianize" data from such processes in a meaningful way, then we can make better inferences. We can solve this problem generally by applying a Lambert W transform (Goerg, 2014), which assumes the observed data is distributed as Lambert W x F_X, where F_X is the distribution of the latent input (Goerg , 2011). To apply this transform, we need to estimate parameters of the Lambert W x F_X distribution and also support the inverse transform, so that we can make inferences about the latent input. With this project, we want to support Lambert W x F_X distribution in Stan in an inferential setting, which means: users can build Gaussian models over non-normal data in a transparent way.
The objective of this project is to develop a new Sugarizer Measure activity which will work on Android/IOS platform and browser. The Measure Activity is a tool that allows kids to indulge in "learning by doing". It provides an interface for the kids to connect with the physical world and an opportunity to view and understand through a visual and statistical representation of the physical phenomena. Through this activity, children will learn concepts related to sound.
A variety of polyphonic synths seems missing in Pd vanilla and is a daunting task to implementing on the go. This project aims to build a General Midi Synthesizer Library using Pd Vanilla objects and abstractions, mainly comprising of:
The library will broadly consist of two-channel polyphonic synthesizer-instruments/percussion- instruments wrapped around through abstractions. Apart from accepting common MIDI input for playing, polyphonic synths will be available as their own abstraction for free use in some other project for performance using sequenced programmed input or even more. Having this library will not only pave a way for easy synthesis in Pd but furthermore, it will also help in enriching the learning and exploring experience for Pd enthusiasts.
The WARP-V is an open-source and highly configurable, adaptable, and flexible Core generator. It supports various ISA like MIPS, Open-Source RISC-V, and can even be configured with custom ISA. It is designed using emerging “Transaction-Level” modeling that takes advantage of advanced digital design features, timing-abstract nature of language features provided by TL-Verilog. My Project Proposal to harness its advantages and develop support for the multicore NoC design creating a custom kernel interface and deploying it on the cloud via the already existing 1st CLaaS framework. This project will not only lead to a highly configurable many-core hardware accelerator but it will also serve to motivate the industry toward FPGA-accelerated web applications and FPGA-accelerated cloud computing and also to demonstrate the flexibility of TL-Verilog and WARP-V to motivate the industry toward better design methodology.
As we know FIneract CN Mobile is a mobile field operations app built upon the brand new Apache Fineract CN micro-services architecture, with an MVP architecture and material design. So this year the focus of this project will be on providing very necessary and some UI-specific functional enhancements to the app. This project will cover the following tasks, integration of Payment Hub to enable disbursement via Mobile Money API, Adding UI and functionalities for remaining operations that are accounts, tellers, and products management, Adding FAQ section and multiple theme support, extending the offline mode via Couchbase, writing unit, integration, and UI tests for better testing, and last but not least converting existing Java code to Kotlin for KMM support.
The purpose of this project is to create functions which convert a wxMaxima worksheet to Texinfo. The functions to convert a worksheet will be written in Common Lisp, which is the implementation language for Maxima itself.
The Machine Learning team at the Wikimedia Foundation works with the aim of building ethical ML solutions to help Wikimedia communities and teams in the pursuit of open knowledge. In this pursuit, there is now a need for a new technical infrastructure to help scale these solutions even further. The current system, ORES has been enabling ML at the foundation for ~6 years. The proposed infrastructure, Lift Wing aims to enable more widespread participation and collaboration with volunteers and communities by lowering the bar to contribute models to the system.
The goal of this project will be to train ML models that perform equivalent or better than the existing models without using revscoring and the ORES infrastructure.The goal is to achieve equivalent or better performance on the same task given the original data used to train the models and ensuring that all the libraries they use are open-source and industry standard (e.g tensorflow, pytorch, scikit learn, hugging face, etc) with the exception of mwparserfromhell which is required to parse the wikitext that is included in the data.
Newt is a web-based tool to analyze biological maps in standard formats such as PD and AF languages of SBGN, SBML, and SIF. This project aims to provide database support for Newt. SGBN maps stored on the database using Newt must be stored in an integrated manner ( i.e. fit like a puzzle with the existing database ). Furthermore, Newt must also provide the functionality to query the database for maps of interest based on genes of interest using algorithms such as shortest path between entities, k-neighborhood, upstream/downstream of an entity, etc.
(Neuro)scientific simulation environments: test-driven development?
The problem of identifiability is ubiquitous among experimental scientific research. The core idea is in one's ability to recover parameter values from the inputs and outputs (measurements). If such recovery is theoretically possible then the model is called structurally identifiable. This problem is commonly solved via symbolic computation. In this project, the aim is to augment the existing ModelingToolkit.jl package with algorithms that solve the problem of structural local and global identifiability analyses.
Primary Goal of my idea is to implement a WAF which uses Machine Learning to detect anomalies in web traffic.
While mainly used in data science, Jupyter Notebook’s interactivity makes it a great tool for teachingand learning new concepts and programming languages. The IHaskell kernel allows you to use Haskell inJupyter, but some key features like interactive widgets are missing. This can be a huge drawback for datascientists, teachers and learners. For this reason I would like to try to fix the ihaskell-widgets library.
3Scale’s API Management service allows us to manage APIs with features like authorize, rate-limit, and monetize, etc.
In this project, we are going to implement an in-proxy cache as an Envoy filter extension to add necessary smarts to avoid calling SM API for each request requiring authorization. The target benchmark to beat would be “1 auth and rep (using authrep.xml endpoint)” per request. The filter will be written in Rust and then later “translated” into WASM code packaged as WASM Module which is loaded on WASM VMs spun up by a runtime (V8, WAVM, or Wasmtime) embedded inside the Envoy.
Many advantages come with using the WASM module instead of the native C++ extension like dynamically loading the filter extension, abstraction from the underlying CPU and programming language used, and being safe from crashing the proxy when a developer makes a mistake. Even though the module is sandboxed, it has the capability for I/O as described in the ABI Specification which empowers us with access to shared data storage (key-value based) and a message queue used in this project.
Currently, DepClean has a plugin to analyze maven-based java projects, but we can't use it in Gradle-based java projects. The main aim of this project is to implement a DepClean plugin that will analyze Gradle-based projects too. Also, the existing plugin may misbehave in a multi-module project analysis as it analyzes only one module at a time. So, this project also aims to make the plugin able to analyze multi-module projects such that a combined analysis will be carried out on all the modules.
Currently, the IBus theme follows the global GNOME-Shell theme in GNOME and the global GTK theme in other desktop environments, and IBus lacks customization for users in GNOME.
This project aims to make IBus themes separate from the current GNOME-Shell theme and GTK theme so that users can customize it with other available GNOME-Shell themes and GTK themes.
Add more features to Customize IBus, including customization of orientation, animation, font, ASCII mode auto-switch, reposition, system tray menu entries, input source indicator. Theme and background picture follow GNOME Night Light Mode.
SecureTea Project provides a one-stop security solution for various devices, I would like to contribute the following features to the Project to make it better:
The main goal of the project is to provide the user of DeepPavlov Framework with an out-of-box solution for relation extraction. I would consider relation extraction as a multi-label classification task and design a pipeline that could reuse the existing DeepPavlov components (such as NER with incorporated tokenizer, already implemented MT-BERT, and others) as much as possible. I would train several relation extraction models with different parameters (for example, different training data, classifier, classifier inputs, inputs encoding, number of relations to be extracted, etc), add them to the DeepPavlov storage, and give the user an opportunity to load them (and, occasionally, additionally train with his/her own training data) and find the one that would suit his/her data the best way. The user's input would be a text and a config with RE parameters, and relational triples would be the output. Thus, the whole preprocessing, data encoding and model application would happen inside the module, while the overall relation extraction component remains clear and convenient for the user.
Currently Menus and Options are shown by default in top and bottom bars, and the default zoom is smaller than the screen's drawing surface, resulting in lost space on the sides of the image. The goal is to have the already existing full screen functionality active by default and find an intuitive way to show menus only by fading in and out depending on whether the finger leaves or touches the screen.
This project aims to migrate the AnkiDroid App to Scoped Storage. It will follow Google's recommended approach. This will involve migrating user data from Legacy Directories to those accessible by Scoped Storage. AnkiDroid's users' collections will be migrated to App-Specific Directories. Media will be stored in their respective Scoped Storage collections. Two migration mechanisms will be developed:
This will ensure the data of users who update at any time will be migrated.
Moreover, this project aims to support all AnkiDroid features under Scoped Storage. It will ensure support for Import, Sync, AnkiDroidAPI client apps, opting for external storage & preserving data post-uninstallation. Scoped Storage inevitably forced some changes in app behavior like the need for migration itself & user data being deleted upon uninstallation. This project will enable a smooth transition by providing a short introduction to these changes.
React has evolved a lot since the initial development of react-native elements. The library needs to update its codebase to adopt a new coding pattern to optimize the performance. With the introduction of Functional Components, a new approach of Hooks was introduced, which makes code clean and more efficient in use. The idea is to migrate components to functions & hooks, tests to React Native Testing Library, and use of the latest APIs of React Native, including Pressable & Animated API
Escape analysis is a classic problem in compiler analysis. Julia compiler has an existing AbstractInterpreter framework for managing inter-procedural analysis of type through data-flow analysis. But the existing framework has very limited support for escape information.
In this project, we are implementing escape analysis via extending the current framework or via implementing a new framework and integrating it into the compiler. With better escape information collected, we are able do more kinds of optimizations including converting heap objects to stack objects and scalar optimizations.
The goal of this project is to improve the conversation between Sage and GAP (the SmallGrp package). We want to create convenient ways for mathematicians to access lists or information about all small groups with certain properties. The current configuration only allows for you to call one group at a time, but we aim to allow for lists of groups which meet certain parameters, as well has improving the information that can be provided about each group. The group properties we aim to address include abelian, solvable, nilpotent, given order, dihedral, semi-direct products, alternating, symmetric, permutation, general linear, and special linear.
Along with this we hope to create a sample web page (wiki) for undergraduate abstract algebra students that introduces interesting ways to use the features that we have created. This is to help provide better instruction and introduction to all the ways Sage can be used even in the beginning stages of higher-level mathematics classes.
Zulip-terminal is the official terminal client for Zulip which has been actively developing for the past few years and has already reached a certain level where it’s no longer considered a temporary client. It still has a long way to go to match the level of web-app, in terms of feature enhancements. So, my primary objective this summer would be to provide more feature support to Zulip-terminal and improve upon the existing ones by fixing bugs and potentially adding and improving upon the test suite. Some of the highlights of the work that I'll be doing:
Time series analysis has become a fundamental ingredient in modern-day astronomical studies. A common approach for characterizing the properties of time-series data is to estimate the power spectrum of the data using the periodogram. But the periodogram as an estimate suffers from being:
This project aims to implement and integrate a superior spectral estimation technique, known as the Multitaper Periodogram, into Stingray. It, as an estimate, is attractive because it directly trades off bias and variance for frequency resolution; it is consistent; and is fast to compute.
This integration would follow the library’s existing design principles so its current users can use this technique to better interpret their time-series data.
The tapers, or data windows, applied to the data in the time domain before Fourier transforming are characterized as being the most nearly band-limited functions possible among functions defined on a finite time domain. These are the discrete prolate spheroidal sequences (DPSS), or the Selpians, and help reduce spectral leakage.
We have to create a service for VCell users that allows Fiji/ImageJ scripting to directly access the VCell client. We have to expand this service into a series of user-friendly plugins for ImageJ that will automate processing and analyzing cell imaging simulation experiments.
The aim of this project is to allow users to quickly edit the text of different components and modules of their websites without having to leave the frontend or going to a different page. This will save time if changes they need to make are small. Normally if there is a typo on the page, one has to first see if it is in the article's heading, its content, module title, module's content, banner, etc. And then open the respective edit page of the component. After this project is completed, it will be so easy to edit the text of almost any part of the website. This project will also be helpful if the user wants to see the end product while modifying the page.
The OpenCV Python package (cv2) currently does not include type annotations, a feature introduced in PEP 484. The project aims to provide type annotations to the package, addressing Python typing stub #14590. This would improve cv2 integration with Python IDEs and enable the use of type checkers, which could efficiently ensure compatibility between cv2 and the Python code samples.
The Project Machine Learning for Macro Diffusion Indexes aims on creating series of potentially useful diffusion indexes and the data that may be used to construct them. Then applying random forest and/or other appropriate machine learning techniques to the data, with the goal of demonstrating the relative performance of those methods.
The present account creation process in Pidgin seems a bit intimidating to the non-technical users, so this project idea would focus on making the account adding process easier for everyone by introducing an Account assistant for Pidgin3. This assistant would help users to add their accounts into pidgin with the protocol of their choice and have multiple pages made up of gtk widgets inside GtkAssistant which would guide a user in adding their account. Introducing this feature would attract more users to add their accounts and use Pidgin with ease.
Pythran is an ahead of time compiler that takes advantage of SIMD instructions to speed up Python code. Currently, in SciPy, there are many algorithms that are too slow as pure Python and could be accelerated via Pythran. Therefore, this project aims to identify such algorithms and use Pythran to improve their performance. Moreover, there are many function in SciPy don't have benchmarks yet, so writing new benchmarks is also included in this project.
Machine learning datasets are often continuously modified yet there is no efficient way to determine if two datasets are the same. This challenge becomes problematic when the datasets are large (20 GB+) and cannot be easily loaded into memory.
This project intends to use Locality Sensitive Hashing (LSH) with the MapReduce paradigm to compare large scale, out of core machine learning datasets.
Semantic information is essential for rich IDE features such as go-to-implementation and rename.
Metals utilizes semantic information extracted from the compiler in a SemanticDB data model form to realize several features. However, SemanticDB generated from Scala3 lacks some kinds of information: Signature and Synthetic. Therefore some IDE features are not available in Scala3 projects.
The objective of this project is to improve the SemanticDB extractor for Scala3, and pave the way to better Scala3 support in Metals, scalafix, and other dev tools relying on SemanticDB.
Libreswan implements the IKEv2 (The Internet Key Exchange Version 2) protocol which mainly uses authentication mechanisms based on X509 certificates and the PKI infrastructure. However there are situations in which distributing rather large certificates or certificate chains is undesirable and impractical. An example could be resource constrained IoT devices with limited processing power or memory. In this case it would be useful to enable raw public keys, instead of using PKI certificates.
Currently libreswan does provide support for raw public keys, but only RSA public keys are supported. It would be useful to provide a unified interface to allow all other types of raw public keys in IKEv2, for instance public keys based on Elliptic Curve Cryptography.
The Project includes :
These improvements will allow administrators to publish and maintain the CDLI’s entities since options are presented hierarchically with keeping the administrators' workflows in mind. Also, the project aims to solve discrepancy problems by merging the templates and enhancing the UX. I have included some designs in my proposal for implementing the above tasks and will incorporate suggestions in design by its actual users at an early stage of GSoC. Once the Front end is done with the existing sass elements to unify UI with existing pages, then I will be checking for any Violations of WCAG using Axe Devtools and will reiterate the front end.
DBpedia Spotlight was released in 2011 by DBpedia. It is a tool that allows to annotate DBpedia resources in text, providing a solution for linking unstructured information sources to the Linked Open Data cloud through DBpedia.
To make this possible, a model must be created for each language using Wikistats (uriCounts, pairCounts, sfAndTotalCounts and tokenCounts), that are obtained from the Wikipedia dump, and the following DBpedia Extraction Framework artifacts: instance types, redirects and disambiguations.
The main idea of the project is to generate a Dashboard that shows statistical information about data collected by DBpedia Extraction Framework and Wikistats. This information will help to have an overview of the existent types of classes, how they are statistically represented (which type of entity is the most common), the trend that exists. In addition, it is intended to add a comparative element between versions of the same language which will help to appreciate changes from one version to another (number of entities, types of entities, trends of each version, etc.). All this information can be used to improve the identification of topics in documents.
Tracker-miners is the indexer used for extracting the metadata from different file types. The project aims to provide the support for storing creation time of the files, and later provide the feature of searching by creation time in Nautilus.
Implementing following dimensionality reduction techniques and clustering algorithms to clusterMaker2: UMAP, t-SNE, PCA, PCoA, Louvain, Walktrap, Edge Betweenness, Surprise, DBSCAN, Spectral clustering and Self Organizing Map. This project is a continuation from last summer's clusterMaker2 project, when I implemented a feature that allows running the algorithms on a remote server. These algorithms that will be added will also use the remote feature.
User scripts are the JavaScript programs that provide Wikipedia users the ability to customize and change the behavior of their user account. Numerous user scripts and gadgets (promoted user scripts) are available for users to install quickly. Users can also write their own user scripts by either starting from scratch or forking an existing user script.
Even though MediaWiki has excellent documentation on user scripts, it’s quite overwhelming. Owing to the powerful functionalities that user scripts provide, one should be able to get started with them easily. Guided Adventure Tours is one such medium that can enable amateur developers and users with a little bit of JavaScript knowledge to learn about them in an interactive, stimulating, and appealing way.
This project is about creating a UserScript/Gadget guided tour to facilitate users to learn about user scripts and how they are created using fundamental constructs such as MediaWiki JS Module (ResourceLoader and its core modules), MediaWiki Action API, and OOUI (used to create interfaces with object-oriented paradigm), in a consistent manner.
This project aims to improve the current active sampling strategy by implementing other information measures such as information density and diversity based on the embeddings produced by known open deep learning models that uses either supervised or unsupervised approach
The project aims to develop Jupyter notebooks for use case examples that explain the Machine Learning workflow of DFFML API.
The Newman Dashboard aims to provide a WebUI dashboard which can let users control and view the currently executing as well as the previously executed newman runs. This feature would be similar to implementing something like the Kubernetes Dashboard which has empowered users to control and debug their clusters from a single endpoint.
Newman is a command line Collection Runner for Postman. It allows you to run and test a Postman Collection directly from the command line. It is built with extensibility in mind so that you can easily integrate it with your continuous integration servers and build systems.
The Calendar view project is to build a section in rocket.chat that will display all user activity inside the app as a list, to show where you were active by certain criteria: For example, when/where the user:
Machine learning models have demonstrably achieved significant success in data classification and prediction across innumerable industries and applications. Today, rolling out a new model has become ever easier with the popularization of open-source frameworks such as scikit-learn and MLJ. Despite the unprecedented accessibility, designing effective models with appropriate hyperparameters remains obscure for the common user without high-level technical understanding and expert intuition. In an effort to automate the process of tweaking hyperparameters, MLJ has introduced a unified interface for tuning models, providing support for widely used strategies like grid and random search. The available schemes, however, primarily perform exhaustive testings on selected hyperparameter combinations. In this proposal, I present a plan to implement a new strategy, particle swarm optimization (PSO), which utilizes information from past attempts to improve hyperparameter search. The first section offers a summary of the method and existing implementations, while the second sketches the technical details of a PSO algorithm for MLJ and a tentative timeline to deliver the project’s goals.
The aim of this project is to build a program that can be used to validate and convert Structured Markdown to the intermediate JSON Representations.
Mission Support System (or short MSS) is a software that is used for atmospheric research flight planning by scientists and meteorological researchers. It is a tool that uses various sets of forecast data in combination with a web map service to analyze the data and place the waypoints for planning research flights accordingly.
The present documentation of the Mission Support System client software covers the basic installation and offers a brief description of the use of the MSS client UI but lacks a vivid and lucid explanation of all the elements and features of the User Interface. The practical usage of the software has been lacking in the existing documentation. To enhance the user experience and to convey a deeper understanding about the practical usage of the software, I propose to create comprehensive and auto-generated video tutorials by a programming script that will be a helpful guide for the user.
The project aims to build a simple web dashboard/webapp that will display and monitor data and metadata from various database backups that are produced everyday in WMF production environments. In addition, the web dashboard will report on the status of these backups or it's errors and will also show the status of past/ongoing/future backups. This will help WMF Database administrators provide a good overview of database backups processes and whether the backups processes are working properly (or not!)
The database metadata will be exposed through APIs and then can be used to make a webapp to display the data. As this data is exposed through APIs, other applications can be built upon it.
In order to enable easier maintainability and collaboration among open source developers, we will try and maximize code coverage for testing in this project.
The goal of this proposal would be to implement the htsget protocol in pure Rust using the noodles crate. It also has the objective of making a serverless implementation able to run as a service under the AWS Lambda Payload
CalibrateSDR is designed to accurately determine the frequency offset of an SDR via an IQ recording sample. Cheaper SDRs use a low-quality crystal oscillator which usually has a large offset from the ideal frequency. Furthermore, that frequency offset will change as the dongle warms up or as the ambient temperature changes. The end result is that any signals received will not be at the correct frequency, and they would drift as the temperature changes. CalibrateSDR can be used with almost any SDR to determine the frequency offset. As of now, it uses the synchronization channel symbols from DAB+ digital audio stations to determine the offset. The primary focus of this project is to extend the applicability towards more signal standards, so as to make it helpful for the SDR community. As DAB+ is mainly used in Europe, Signal standards like GSM, LTE, NOAA-Weather Satellites, DVB-T (use their sync pulses within the data) can be used. Currently, it uses the pyrtlsdr package, which makes it work with RTL-SDR. Piping the API to work with other SDRs will also make the project have a wide range of applications in the SDR Community.
The project aims to improve the integration between ScalaPy and Ammonite/Almond by providing a frictionless installation experience plus a number of quality of life features such as code completion and displaying rich presentations of Python objects. The project also involves developing a Scala - Python integrated environment in which users can switch between a Scala and Python shell and exchange variables between them. The project could benefit Scala programmers seeking access to Python libraries, typically data science and deep learning frameworks, by providing them with a smoother user experience. In addition, it could also help Scala attract Python programmers, who are looking for a type safe language with better concurrency and parallelism support.
Currently, the website just supports desktop is doesn't have compatibility for touch devices. Adding Touch compatibility using libraries and adding a new UI for the version of the small device. Finally integrating into the app using in-app web view.
The CFC mobile application (Educult) project aims to add some specific features to the Mobile Application which will allow students from all over the world to develop their skills and help each other more supportively. The aim of the project is to implement a classroom and doubt forum functionality so that students can gain knowledge by helping others by providing an answer to the doubt questions in the doubt forum and by enrolling in various programming Courses.
ODK-X Survey is a data collection Android application, similar to ODK Collect. Users can create forms using XLSX spreadsheets and are then rendered to them on their mobile device. It is built with HTML, CSS, and JavaScript in replacement for native Android development. Forms are synchronized to a server and support various prompt types including but not limited to free text, numbers, geo-points, and audio.
Currently, the form accepts the date and DateTime prompts. The date prompt gets the date from the user using dropdown menus whilst the DateTime prompt gets the date and time in a similar manner.
The goal of this project is to include more prompt types including month only, year only, month and year only, and non-Gregorian calendars for users to choose from. The programming languages used to develop these include HTML, CSS, and JavaScript. The project also ensures that once implemented, these new prompt types are compatible with the ODK-X XLSX Converter. The new prompt types are then added to the converter’s documentation including how to make custom prompts.
This project proposes the design and integration of a deep learning framework into Audacity, with the focus of developing an interface for end users to interact with state of the art (SOTA) audio source separation models. Although the vast majority of SOTA source separation algorithms are built using Python-based frameworks, PyTorch’s C++ torchscript API provides an elegant solution for deploying python models in C++ applications. In Audacity, this would introduce the opportunity for the user to choose from a collection of domain-specific pretrained models, each suited for a different task (e.g. speech or music). Additionally, it would set the foundational code for future integration of deep models designed for different tasks, such as speech recognition and audio classification. The goal of this work is not only to integrate source separation algorithms into Audacity, but more importantly to lay the groundwork for an extensible suite of open-source, deep learning-based music information retrieval (MIR) tools hosted by the world’s most popular free and open-source audio editor.
The primary focus of this project is intended to improve the engraving support for static tempo markings, by allowing the user to input complex temp markings with ease. The project will also add "Relative Tempo Changes" which are another category of static tempo markings. Once these goals are achieved, and enough time is available, the project will tackle adding basic dynamic tempo changes which have been a long requested feature. Once fundamental support for dynamic tempo changes are done, tempo resets will be added to complement both the static and dynamic changes
Currently, there is no social aspect to channels in Rocket.Chat as many public channels aren't visible enough for the users to view and join. To join a specific channel, they should either know its link or the exact name to search it in the Directory. Also, every single day Rocket.Chat servers have many people coming into their channels, and they are all lost. They do not realize that there exists tons of discussions and threads within a channel. So, there can be a better way of letting the new users know what is going on within the server or even within a channel. This project aims to solve the above two issues by introducing a new feature called Discovery!
Having a chatbot for Scorelab's Gitter channel will be very beneficial for the community, as the automation would help the new contributors to get started quickly. Contributors can access the project resources from the chatroom. A chatbot is a great way of receiving updates on the Gitter channel about new PRs and issues made in a project. The idea also offers the detection of unfair, offensive or rude messages that violets the community guidelines.
Oppia Android's current testing corpus includes unit tests using the Robolectric testing framework & integration tests using the Espresso testing framework (to ensure that the app operates as expected in a real Android environment). The current tests have a few limitations: they do not correctly facilitate cross-activity navigation flows which actual users will be triggering, and they do not verify that the app can interact with Oppia's backend correctly.
To prepare for the global launch of the app, we need end-to-end tests that:
We expect that the tests will be written using UiAutomator & are set up for interacting with a local development server (see relevant documentation).
Note that this project requires running Linux with virtualization support (in order to run an Android emulator). You will need to make sure your computer supports KVM and is running Linux.
Create example functions for interacting with sound on p5.js and also examples for creating visuals as feedback to sound. These could be further developed as wrapper functions tied to tone js and be invoked while scheduling tone js events.
The study of substructures in the dark matter has shown signs of promise to deliver on the open-ended and long-standing problem of the identity of dark matter. To probe these substructures, strong gravitational lensing has been used in the past and provided some interesting results. The approaches based on deep learning have the ability to identify and differentiate among these substructures using images from the simulation of strong gravitational lensing. This project explores the scope of use of equivariant neural networks that can benefit from inherent symmetry present in natural images. We will be implementing and benchmarking the results of equivariant neural networks on the available DeepLens simulated dataset. We will also integrate all these architectures with the DeepLens pipeline to provide a high-level interface for future work.
The main objective of this project is to create a visualization therefore farmers can control the state and weather of their crop analyzing atmospheric and ground magnitudes such as temperature, humidity, wind… with an Arduino microcontroller and a django restframework server.
An annotation tool helps people (without the need for specific knowledge) to mark a segment of an audio file (waveform), an image or text (and others) in order to specify the section's properties. Most annotation tools lack the multi-user feature where multiple annotators can annotate a shared file. In this project, we will try to create a sound annotation tool whose system will contain two types of users. The first one is the annotator who will be able to annotate assigned tasks (audio or video files) and export them in multiple formats (JSON, CSV, XML). The other one is the manager who will be able to create projects, add audio files to them (tasks), assign tasks (annotations) to annotators and edit completed tasks. We will follow a strategy where annotators will not be able to see marked segments of other annotators in order to prevent them from annotating based on what the other annotators have tagged.
nMigen is an HDL toolkit implemented in the Python programming language. By using nMigen instead of traditional HDLs like Verilog or VHDL, gateware can be developed in less time, with less bugs, and with extremely powerful abstractions that enable code clarity and conciseness. apertus° has already developed prototype nMigen gateware for the AXIOM Micro, but wishes to extend it to support the sensor, FPGA, and HDMI interface of the AXIOM Beta. This work will develop in nMigen and demonstrate on real hardware an end-to-end imaging prototype for the AXIOM Beta: sensor control over SPI, sensor readout PHY from LVDS, pixel remapper based on existing implementation, 4K to Full HD downscaling debayerization, and final image output to HDMI.
Using Deep Learning techniques in order to model the relationship between the planetary albedo and chemical composition of Mercury.
One of Dask's primary functions is to construct task graphs and optimize them before decorating the functions to operate lazily. By looking at the interconnectedness of tasks, one can learn more about potential bottlenecks where parallelism may or may not be possible to apply to simplify the task graph further.
Dask currently uses graphviz to render a task graph. The .visualize method and the dask.visualize functions are simple and effective. They generate a static black-and-white image showing the blocks and their connections. However, the task graph struggles to work with complex computations and doesn't give a clear idea about the feasibility of the tasks. There's a scope of improvement here.
I plan to color code the graph and highlight the room for optimization (dask.optimization). This allows the user to learn more about the program's performance characteristics and distinguish how the computation fares at a higher complexity. I also plan to introduce collapsible blocks that group smaller blocks into a single large block. This simplifies the rendered graph, especially when the crucial data contains a large number of nodes.
The main goal of this project is to create a component that has a clear API that can provide autocomplete feature for the jupyter kernel - mariadb_kernel. And also I hope that component can be easily integrated with not just jupyter, but also VSCode and Atom … etc popular editor. The main feature has three:
This project requires the completion of the tests regarding SVM and then the separation of the read, write functionality of MetaActions to new distinct classes. The second change aims to make VCL more flexible to refactoring
Javis.jl is a graphical animation/visualization package for the Julia Language which fetches motivation from Grant Sanderson's Python based animation engine viz Manim. This proposal aims to bring a more organized experience for creators and developers via layers, powerful abstractions for improved syntactic sugar, aesthetically pleasing animation tools and the ability to livestream animations.
CCExtractor is the de-factor open source standard for closed captions / subtitles extraction from any media file. It is a tool that analyzes video files and produces independent subtitle files from the closed captions data. CCExtractor is portable, small, and very fast. It works in Linux, Windows, and OSX.
This project aims at making a cross platform GUI for CCExtractor with Google's Flutter framework, for users who prefer GUIs over command line programs.
Pretty printer to show variables and objects in human readable format
Add dynamic load module support for SOF
Create a custom picture selector which indicates what pictures have been uploaded already to the Commos server.
To realise the full potential of probabilistic programming languages (PPLs), it is essential to automate the inference of latent variables in the model, conditioned on the observed data. Hence PPLs usually come with built-in algorithms to perform Bayesian inference on such models automatically. However, due to the expressiveness of PPLs, it is very challenging to design general purpose inference algorithms for models specified in Turing-complete PPLs. Applications tend to build their own custom inference machines, which is time consuming and labour intensive. This proposal puts forward a recently introduced framework—the involutive Markov chain Monte Carlo (iMCMC), as a candidate for inference in a PPL, namely Turing. Such a framework would enable the automation of an implementation of a correct inference algorithm from user specifications in Turing. Moreover, Turing readily supports differentiable programming (in their HMC implementation) which is the main technical requirement of iMCMC. Early iMCMC developments in Gen show promising results compared to standard black box styled inferences. Hence, it would be desirable to have an implementation in Turing.
AOSSIE’s Agora, a voting platform with many great voting algorithms. But the only thing missing in this idea was TRUST. It’s users have to trust the owners or the admin of the central database, that their vote would not be manipulated and can’t be hacked. The only solution which seemed feasible to me was Securing it with Blockchain.
The project focuses on providing Event management and creating a Social Environment for small groups, churches, and other organizations.
The core main features of the project are:
The idea of this project is to make enhancements for making it easier to review issues and submit new high-quality issues and adding functions to run and comment on issues for bugRzilla.
Over the last couple of years, a lot of development effort has gone into two kernel subsystems: BPF and io_uring (https://lwn.net/Articles/847951/). gVisor does not currently support the io_uring interface which came out May 5, 2019 with Linux 5.1. Because of the performances (https://kernel.dk/io_uring.pdf section 9) improvement over the old AIO interface which came out in Linux 2.5, io_uring has grown in popularity extremely fast and some big projects like QEMU are already using it (https://archive.fosdem.org/2020/schedule/event/vai_io_uring_in_qemu/attachments/slides/4145/export/events/attachments/vai_io_uring_in_qemu/slides/4145/io_uring_fosdem.pdf). The goal of this proposal is to implement a part of the io_uring, notably the io_uring_setup and io_uring_enter syscalls and a subset of opcodes.
One of the challenges in High-Energy Physics (HEP) is events classification, which is to predict whether an image of particle jets belongs to events being sought after or just background signals. Classical Convolutional Neural Network (CNN) has been proven a powerful algorithm in image classification, including jets image. As quantum computers promise many advantages over classical computing, comes a question on whether quantum machine learning (QML) can give any improvement in solving the problem.
This project aims to demonstrate quantum machine learning's potential, specifically Quantum Convolutional Neural Network (QCNN), in HEP events classification from image data. Although many previous works have tried to classify images with QCNN, none of them is fully quantum. They were still incorporating classical fully-connected layers after variational circuits. This project will be one of the first to try classifying images with a fully quantum implementation of QCNN and probably the first one to do so with particle jets images.
Understanding the inner wiring of the human brain is one of the most long-pursued goals of neuroscientists. In this journey, diffusion MRI (dMRI) and tractography algorithms offer the essential possibility of reconstructing the white matter bundles that interconnect brain regions. Building on this, it is of high interest to obtain tractography bundle atlases that describe the average connectome in different populations. Constructing these atlases, however, requires specific technical expertise and cannot be done in a simple way by using currently available neuroimaging software.
This project aims to fill this gap by integrating a tractography bundle atlas creation workflow into DIPY, a reference library for dMRI processing in python. The developed solution offers scientists a quick and easy way of obtaining population-specific tractography atlases in an automated fashion. The algorithm takes segmented bundles as input and relies on streamline based registration to align the bundles and construct an atlas. The whole atlas creation process is controlled by the user via a command line interface. Obtained atlases can be exported and used for visualization or further analyses.
Ignition Gazebo is the next generation of the Gazebo robotics simulator. This project involves porting a list of GUI widgets from Gazebo classic to Ignition Gazebo that allows the users to debug their simulations and models. These widgets will provide a better user experience by having better debugging and visualization capabilities in existing simulation worlds.
Example Zoo provides starters a glimpse of most if not all features provided by mlpack, such that users can run the code for themselves to see it in action, maybe change things, Break it & figure out how to fix it. This would enable a starter to become familiar with the library relatively faster than reading documentation and starting from scratch.
The Compact Muon Solenoid (CMS) is a detector at the Large Hadron Collider (LHC) located near Geneva, Switzerland. The CMS experiment detects the resulting particles from the collusion and measures their kinematics using various sub detectors working in concert. High momentum muons are significant objects for many physics analyses at CMS. Therefore, an accurate momentum assignment scheme differentiating low momentum muons (background) from high momentum muons (signal) is crucial to the Endcap Muon Track Finder (EMTF) trigger. The first algorithm implemented in the trigger system was a discretized boosted decision tree. In this study, we will study the use of deep learning algorithms at the trigger level that requires microsecond level latency and therefore highly optimized inference. We will develop and benchmark the graph neural networks (GNN) for momentum regression in the trigger system. As deliverables, we will present the benchmarkings of deep network model inference for muon momentum assignment for prompt and displaced particles.
EnviroCar is a citizen science community that collects, shares, and analyzes floating car data for traffic management and the environment. It analyzes the open data and estimates the track count, average speed, relative speed, CO2 emission, fuel consumption, and hotspot analysis.
EnviroCar app is an android application that provides features like:
The project aims to build a cross-platform application so that the enviroCar app is available to iOS users as well since only two-thirds of people can use the application as of now.
With the advent of Machine Learning, one can learn such heuristics and use them as cost functions in conventional path planners. SNGNN-1D is one such Graph Neural Network based Machine Learning algorithm which evaluates the static scenes generated randomly from the point of view of the robot. In short, it outputs a score between 0-100 which shows how good the robot’s position is with respect to its surroundings. This score, for every state in the room, is used to generate a heat map that is used by A* algorithm to plan a path to the goal position. The problem with this implementation is that it is computationally expensive and is relatively slow, also SNGNN has been trained using static scenes and does not factor in dynamic settings for example, walking humans, which is a very common scenario in a social setting. A more cost effective way to carry out this task would be to train a policy to reach the goal. However, it is difficult to structure a reward function for complex environments. In such cases, Reinforcement Learning is a promising pursuit that can make use of SNGNN-1D as a reward function because it scores the robot’s presence in the room with respect to its surroundings.
In this project we aim to improve the deduction capabilities of the Attributor framework.
I intend to work on the Matrix exponentials task. Matrix exponentials are used in solving systems of linear differential equations. It is also widely used in Quantum Mechanics (Schrodinger's equation: Describes the way a quantum particle behaves) and in Control Theory. I have been fascinated by the concept of Matrix exponentials right from the time I had the introduction in my Linear algebra course. The theoretical implications of the matrix exponentials have interested me very much. I had a chance to go through the “Scaling and Squaring Algorithm” for matrix exponentiation. In this paper, The technique of calculating the pade estimate to categorize which pade value to be used for optimization has interested me to pursue this project. I also hope to understand and achieve the parallelization of the current task for efficient computation of matrix exponential and be challenged by the intricacies specific to the programming language.
Lightning is a tool used to import large amounts of data into TiDB. In addition to the logic of preparation and improving performance, the main logic of lightning can be divided into two parts:
These two steps are in the logical layer. However, in the implementation layer, these two steps are coupled. Therefore, when support for KV database like HBase, lightning still needs to convert KV like data to SQL first, and then translate SQL to KV like data again.
I will try to implement this feature by enhancing the ability of local backend, refactoring the logic of the import table, and so on.
ERDDAP is a data server widely used in many organizations over the world to upload and gather data sets on the ocean environment, but currently it only supports English and not all users are proficient in English. This project will create an automated tool to translate the user interface of ERDDAP into any target language, and also modify ERDDAP’s structure to allow one ERDDAP setup to display messages in multiple languages to enhance the accessibility of the oceanographic data for the scientific community.
OpenQA is an automated testing framework for OpenSUSE automated testing initiative.The framework allows you to test GUI applications on one end,bootloader and kernel on the other.OpenQA runs Virtual Machines and closely monitors their state and runs tests on them.
The testing framework is divided into two:
-The management logic (test scheduling ,management,high level API)
-The Webfrontend
The proposal is intended to develop a backend capable of directly interacting with different container technology i.e docker allowing the software to test container images before release.This would be useful to enhance the development and publication workflow of containerized environments.
The backend will be able to provide an abstract interface to allow os-autoinst and the test cases to interact with the specific container technology and provide the same integration to the current workflow.
hashesDB will be a command line tool that will help users manage a database of hashes of files. It will provide several database-related functionalities such as insertion, deletion and searching. It will also support fuzzy hashing, a hashing technique based on Locality-Sensitive hashing that makes it possible to perform similarity checking with the use of hashing.
PyMC3 provides state-of-the-art tools to specify rich mathematical probabilistic models and algorithms to efficiently approximate the posterior distribution of such models conditioned on observed data. One such algorithm is the Sequential Monte Carlo (SMC) sampler which is capable of drawing samples from complex posterior distributions (e.g., multimodal distributions).
In addition to traditional Bayesian inference, SMC can also be used to perform Approximate Bayesian Computation (ABC), which allows one to define models without a pure mathematical likelihood term, which is difficult to derive in many complex real world problems. To achieve this, SMC-ABC makes use of a “Simulator” function that is capable of returning simulated observed data given different unobserved parameters.
This project seeks to extend the documentation, performance and flexibility of SMC and SMC-ABC sampling in PyMC3, to make it competitive with specialized libraries while remaining accessible to the large user-base of the PyMC3 library.
Currently, the basic structural verification of CRD has been done in APISIX Ingress Controller, but more verification is still needed. For example, plug-in schema verification, dependency verification between APISIX objects, rule conflict verification, etc. In this project, I will be working on enhancing the verification for APISIX Ingress Controller by implementing validating admission webhooks. So that some errors caused by YAML when users define CRD will be avoided.
Ruby has introduced the important Fiber Scheduler (Samuel Williams, 2020) support with the release of Ruby 3. This closed the long march of improving Ruby’s asynchronous I/O performance since the proposal of AutoFiber (Eric Wong, 2017). But we still have lots to improve. By supporting pre-actor APIs, we could better use the state-of-the-art Linux io_uring APIs, and have better support on Windows IOCP. This proposal aims to enrich such supports in Ruby interpreter to improve the Fiber Scheduler in Ruby.
Robotics Academy is fully oriented to service Robotics and Computer Vision. It comprises a collection of exercises, including recent service robot applications in real life, with different robots such as autonomous cars, drones, or vacuum cleaners. Industrial Robotics is an open-source collection of resources for JdeRobot and exercises for autonomous robotics manipulation. Last year, they incorporated three exercises based on robot manipulation and navigation. Now, the plan is to extend these exercises to Web Templates. For each exercise, a template performs all the auxiliary tasks such as the graphical interface, connection to the sensors and actuators, timing of the code, etc. This also hosts the student’s code. Using this template, the student focuses on robot intelligence (for instance, perception and control algorithms) without wasting time on auxiliary details with little educational value.
Deformation is one of the most ubiquitous and recognizable physical phenomena: trees swaying in the breeze, a bouncing ball, someone poking the Pillsbury doughboy. This familiar behavior can make all the difference to an immersive gaming experience. Simulating this behavior in real-time often falls within the domain of soft-body dynamics, for which Godot provides support in 3D.
After discussion with developers in the Godot community, I have decided to focus my attention on two specific, feasible tasks that would improve soft-body dynamics in Godot:
These two tasks are interrelated in that they both focus on the application of forces (body and external) to soft bodies, and I hope that their completion will illuminate a more general pattern by which this is best accomplished for future soft body improvements.
The goal of this project is to set up tests using Cypress and our new Cucumber test engine framework. The tests will automatically run against the UI, based on user workflows.
Clinical Data Management is a child project under Modernizing Administrative functions for OpenMRS. The project focuses on porting administrative functions for managing clinical data within OpenMRS to OpenMRS 3.0: A Frontend Framework.
As frontend technologies have evolved quickly over the past 5 years, many sites have started making their own front ends for the platform, Thereby, OpenMRS is moving from legacy server-rendered pages to React using Carbon Design within a micro frontend framework.
I have proposed how I will be working and what design principles and carbon design components I will be using during my summer and what contributions I have made in the past. Alongside, I have attached a draft timeline for the summer contribution and how I will execute my project and all the necessary coordination required during my work.
This Project Proposal is aimed at making the Android client more extendable and easily customizable so that it gets to production and helps solve some healthcare Issues.
The fastly developing hyperparameter tuning framework Optuna has gained much attention in the machine learning community due to its high flexibility and rich features. One of the most important features in Optuna is the visualization module, which provides various APIs to help users to analyze the optimization process and possibly adjust or early stop the process correspondingly. However, currently, these APIs are called by the user manually and thus makes the monitoring process hard. In this project, we aim to develop a web dashboard for Optuna (Optuna-dashboard) to monitor various optimization processes, which will greatly simplify the monitoring process by automatically visualizing the optimization “study” in optuna in real-time.
My proposal two
Since cache performance is one of the essential metrics that may bottle-neck the overall performance of the system, monitoring it and identifying points of weakness (and resolving them) may drastically improve the performance of the system.
In this project, a cache modelling QEMU TCG-plugin is proposed and implemented, with simplicity rather than intricacy in mind, that models the behavior of caches when given the working set proposed by a program, or system-wide working set, report the cache performance, and identify the frequently cache-missing instructions.
The idea of playing games on the Liquid Galaxy has already been explored by some developers, there are currently two classic retro games that have been implemented: pong and snake, but there is no easy way to install and run these games on a Liquid Galaxy. By creating a basic app with icons representing each game any person with a tablet could easily control which game is being displayed on the screens and even quickly switch between them.
Besides that, the Pac-Man game is another classic retro game that has been around or over 40 years and is one of the most famous of all time. What if there was a remake of the game for a more modern and multiplayer version on the Liquid galaxy to be included in this new app? Not only would it bring nostalgia to people all over the world, but also bring a lot of visibility to the Liquid Galaxy in a more fun and casual way.
This project aims at improving the workflow for managing streams by improving their editing UI, adding more permission sets, refactor existing permissions to make it is easy for both users and administrators to handle subscriptions for streams more easily by finishing long-pending features like Default Stream Groups.
As stream settings and left sidebar is closely affected by any change in either of them so a parallel aim would be to improve Zulip's left-sidebar according to changed stream settings features and also to add new features to it so that it becomes more interactive rather than just listing streams/topics/PMs.
I also aim to improve the performance of web app for narrowing to different message views, by fixing various high priority issues that are related to the message view area. Along with performance-related issues in message viewing I aim to solve issues related to interleaved views in Private message views by utilizing recent topics UI for this and improving image previewing support for messages.
The project aims at dealing with the conversion of CiceroMark to DOCX (OOXML) and vice versa. In the first portion, we are gonna improve the add-in by improving the existing features and addition of new features which generally includes the ergo expressions and inline blocks of a template. Apart from these, there will be testing of data to ensure that the correct data is entered into the variable fields to avoid any inconsistency. The second portion involves the conversion of the OOXML to CiceroMark. In this, improvements will be made to the OOXML transformer present here. The current transformer works only for very basic OOXML. We need to extend the functionalities of the transformer to support more ciceromark and commonmark classes like lists, optional, inline, ergo formula blocks. In this way, we will ensure more flexibility and portability with the round trip transformation of the smart clause templates.
The proposal shares product and technical design for the project idea "Improving Front-End Typed System" under Oppia-web. The current codebase doesn't pass strict type checks for all typescript files present.The project Aims to fully cover 120 services along with their test files listed from the codebase to pass strict type-checks.The document also shares the full implementation approach of the idea and the milestone I would have to cover while completion of this project
This project is to load 3D Models in PLY format from the CDLI database into the existing 3D Model Web Viewer using the Three.js library. The idea is to implement an RTI Viewer so that any CDLI tablet for which the PLY model is available has an easy-to-navigate option for the 3D viewer for that model.
The main aim of the project is to build a desktop tool that demonstrates how to build desktop apps using Flutter and at the same time be of some use to the Flutter Developers. The app will ideally be deployed to the macOS App Store, Windows App Store, and if time permits, even to the Linux Snap Store. The code will be available on GitHub for everyone to learn from.
This project is to automate reinforcement process of slab and footing by using the Reinforcement Workbench in FreeCAD.
The project aims at implementing support for pseudo-localization in Godot. Pseudo-localization is an important tool for internationalization. It offers the developers a way to check if the project is internationalized properly without actually translating the project. For example, the wikipedia article on pseudo-localization gives an example on how pseudo-localization would translate Account Settings to [!!! Àççôûñţ Šéţţîñĝš !!!]. Thus, Pseudo-localization involves replacing all characters in localizable strings by some special characters along with adding some constant padding to check whether the UI is robust enough to handle changes due to change in locales.
I plan to work heavily on improving the cloning capabilities of Snare, modify and upgrade aiohttp to be compatible with Tanner (v3.7.4) and add support for Python 3.8+. Apart from this, I also plan to help out with some issues that will help make Snare and Tanner more complete and provide a better user experience.
A monitoring system is essential for system admins to manage servers. This project enables Jenkins agent nodes to provide their metrics to monitoring servers even when the agent-controller connection is lost. This project proposes a new plugin to achieve this objective and focuses on managing the threads in the agents and extensibility for various monitoring servers.
AiiDA currently has a REST API, built on the flask framework, to provide access to the provenance graphs in the database. The REST API is limited to queries to AiiDA databases. It does not provide any support for workflow management.
This problem can currently be circumvented using python dashboarding tools like plotly.dash or by developing a specialized API for it like aiida-post. While these alternatives have their own advantages, they come at the cost of either mixing data, visualization and controlling logic or investing time to implement a custom API and client. The objective of this project is to extend the AiiDA REST API by:
Adding security features to the What You See Is What You REST addition to Pluto notebooks, and creating simple methods to deploy notebooks as REST APIs.
The main security features would include macros for specifying which variables are modifiable and which variables are requestable, and an option to run the notebook in "API Only" mode which would only allow access to the API, but not the notebook itself.
For easy deployment methods I would create tutorials and default files where necessary for fast and simple deployment to common services. This would include creating Docker Images and Containers, and tutorials for hosting on common services such as Google Cloud, AWS, or Heroku.
This project is about extending Ruma's API coverage. The final goal for this project is to have a more complete coverage of the Matrix spec, along with implementation of two recent MSCs in Ruma.
The three main milestones for the project are the following:
However, other tasks are part of the project schedule. These are of a smaller scale, but aim to help me get more familiar with the code base, or just generally improve Ruma.
The code base of Music Blocks is being refactored. This gives us an opportunity to revisit a number of UX issues, including the design and implementation of the various tools it provides for debugging. There are some ideas, such as changing the appearing of a block that is throwing an error, better handling of break points, visualizing program status, etc.
NeuralPDE.jl is a Julia package that employs neural networks to obtain a solution of high dimensional differential equations and hence overcoming the curse of dimensionality.One of the techniques that uses Scientific Machine Learning to solve PDEs is Physics Informed Neural Networks (PINNs). The project aims at extending the application of the PINN algorithm to integro- differential equations. The project also propose to add support for constrained equations and different geometry for PINNs.
The package mcmcse is the leading package for estimating Monte Carlo standard errors for Markov chain Monte Carlo and reliable calculation of effective sample size. The package performs multivariate output analysis on extremely high dimensional Markov chains of the order of a thousand components and lengths exceeding millions, experiencing bottlenecks in efficiency. The primary goal of the project is to systematically identify and clear efficiency bottlenecks via detailed benchmarking and testings. This project will focus on improving the implementation of critical subroutines, like batchsize() and mcse.q(), of the package. This would involve migrating to Rcpp, parallel implementation of functions and implementing alternate algorithms for the task. In addition, improvements to the existing implementation by correcting for numerical instabilities, Rcpp sugar implementations, solving for error or warning messages in corner cases, updating documentation and developing a class identifiable with the output form an integral part of the project. A list of additional tasks specific to certain functions will also work towards improving efficiency and accuracy of the package.
Current implementation of 2D convolution can benefit from having an interface similar to already developed 1D convolution in the library. This project aims at aligning the design of 2D convolution with 1D convolution and improving its performance.
The supercomputer that is currently constructed at the LHCb will allegedly be the largest real-time data acquisition system in the world in 2021 and operates at very high speeds (up to 32 Tb/s). To avoid losing critical physics data through the network and to ascertain its high-speed real-time operation, the network has to be monitored carefully.
This project aims to design and build a GUI application that can visualize the DAQ network, the routing configuration in the switches, and conflicts with relevant details in the network for a given input traffic pattern. The end product can be used to monitor the high-speed network in real-time.
Currently, the process of generating the documentation is manual and it requires updating the docs every time there is a change in props. We can use document generator tools to generate documents effectively using scripts. Work on internationalization of documentation. Along with this make a Web App which showcases components.
Make gccrs usable under the cargo build system in order to bridge the gap between rustc and gccrs. The project aims to create a base upon which to expand, in order for gccrs to become a more viable alternative to rustc
This project aims to improve test coverage, finish development of SDKs, add new frontend features and increase the overall resilience and stability of the project. This will be achieved by tackling major issues across all repositories - IntelOwl, go-intelowl, pyintelowl and IntelOwl-ng. Upon the completion of the project, pyintelowl coverage assessment support and go-intelowl will be completed. IntelOwl will have increased test coverage via addition of new test cases for API endpoints and User/Group permissions. A better way for handling unconfigured analyzers will be implemented for IntelOwl in conjunction with IntelOwl-ng for the GUI related changes. Support for social authentication methods will be added and new analyzers will be implemented as well.
To make addition in SimpleCMS so that they can give response in .ESP format and to add feature "Spiral" for better animation.
Astropy is a massive Python library providing methods and general purpose tools for processing and analysis of data generated in astronomy and related fields. It is widely used by researchers and the scientific community at large. One important feature of Astropy is reading and writing tabular data in a wide variety of useful formats. One such astronomical data storage format is the CDS-ASCII format employed by Centre de Données astronomiques de Strasbourg (CDS) for maintaining its VizieR catalog. Currently Astropy only supports reading data from a CDS-ASCII table and not writing to it. The present project is meant to address this issue by adding a CDS-ASCII writer to Astropy. CDS already has an available package to generate standardized ASCII tables for submission of data to its catalog. The proposed Astropy CDS-ASCII writer can be based on the methods used by that package.
On MusicBrainz, URLs are external links attached to entities; relationships define their role and include metadata like date period, they provide extra information about the entity and inspire users to explore further.
Currently, the URL relationship editor on MusicBrainz has many shortcomings. Though it is a relationship, the URL editor has a different UI from other editors. Automatic rules were built to ease the effort, but outdated and buggy rules make them an obstacle in some situations. For better user experience, we would like to enhance the URL relationship editor, to support multiple relationship types for a single link, to provide a unified appearance, better user experience and more flexibility.
As given on the official website, Bela is a hardware and software system for creating beautiful interaction with sensors and sound. Bela consists of a Bela cape on top of a BeagleBone Black computer (uptil now). The idea is to enable smooth transition of the associated software to the BBAI and future TI chips.
Nettacker is tool which can scan and find vulnerability from the target. This have numerous modules, like recent Microsoft Exchange vulnerability module that helps to detect this vulnerability from our target. In this project proposal I have mentioned that how i want to utilize nuclei-templates and add workflow for improving user experience and performance of the tool.
New set of tools will be implemented, for user to effectively select the spectral data in frequency domain, the data selected will then be passed to downstream effect processing, e.g. Noise reduction or removal.
Brush tool will be served as basic deliverable, whereas Hann window will likely be chosen with minimal 75% overlapping for both analysis and synthesis part. Regarding circular-shaped data, Bresenham’s algorithm or Midpoint circle algorithm will be used to estimate the circumference points in frequency domain, the remaining points will be calculated using Flood fill algorithm.
The overtone resonances will now be estimated and selected automatically for the user-selected fundamental frequency. Moreover, the data selected can be refined using slider, to determine the threshold for spectral energy.
Apache SkyWalking already has a Python Agent with relatively complete functions, but it still has some functional deficiencies compared with Java Agent. One of these is the ability to profile running projects. In this project, I will implement the profiling function for the Python Agent of SkyWalking. Because the Java Agent already implements this functionality, so the code in the oapserver and the report protocol can be reused, but the Python Agent needs to implement the code that accepts the profiling task command and the code associated with the profiling sample.
Tarantool’s team has released a new C++ connector, which is based on compile-time MsgPack encoder/decoder. Reaching the limits of C++, this library is really state of the art, eliminating any possible overheads. The project idea aims related to it is: Complete providing support of Tarantool features (pushes and SQL statements)
Add lock button, Equalizer UI, Track management, Next & Previous button MediaElement, extend gesture support, Add docs on how to custom style/bind the LibVLCSharp.Forms MediaElement
The UI Migration project is an effort focused on generating the new component-based architecture with the integration of the APIs. To make the project more efficient and easily accessible, an entire code base shift from Symfony-Twig to React.js is proposed. React.js features an incrementally adaptable architecture that focuses on declarative rendering and component composition. React.js component system will enable us to organize the current working APIs appropriately.
The main objectives of this project are:
This project aims to optimize the performance of Nemo by dynamically splitting skewed tasks of a job based on the information collected from runtime metrics, executing them in parallel, and merging them afterwards. The goal is achieved through the following four steps: First, gather relevant metrics during execution. Second, using the gathered statistics, determine which task is skew(i.e. needs a longer time to finish) periodically. Third, Split the skewed tasks in half and allocate the latter splitted half to the new task. And lastly, execute the new task and check its performance.
Adding new layers (Upsample, Group Normalization and ChannelShuffle) to the ANN module of mlpack. Improve the speed of pooling operations of max, mean and LP pooling layers. Improve the speed of un-pooling operation of mean pooling layers.
XFCE already has sample/skeleton panel plugin but only written in C language that make only C developers eligible to develop or maintain plugin. So during the GSOC period, I will be developing two plugins in multiple languages(Python and Javascript) to make it easy for everyone to understand the basic working and development of XFCE4 panel plugin.
A film can be fundamentally broken into innumerous shots, placed after one another. These shots are divided by cuts. Film cuts can be broadly divided into two categories - Sharp/Hard cuts, Gradual cuts. This work is about the detection and classification of these film cuts. While there are many algorithms for cut detection, few of them yield a good performance efficiency ratio. In this work, a synthetic dataset has also been made from scratch using appropriate algorithms. A method has been used in which the hard cuts and gradual cuts are filtered and processed in different modules using different deep learning techniques. This approach should yield a descent performance and less computational complexity. The proposed model is capable of detecting multiple cuts in a video and return timestamps of the cut occurrence in the video. I have also proposed on making a flask webapp/ pyQT GUI to integrate this model at the backend of the webapp or GUI. The webapp can be added to RedHenLab’s rapid annotator.
Fractal currently supports only one account, if you want to be connected at the same time with different accounts the user has to launch several instances. I would implement multi account support in the client so users can have more than one account connected at the same time with a user friendly interface. I would need to work with GNOME's design team to come up with the interface. To add multi account support first there is some work on the backend to do, then we can work on the interface. I will take the fractal-next branch as the basis for this work.
Metacall acts as a middleware between two languages using which we can call function present in one language from another. Java is a high-level programming language that should be a part of the metacall project. The three APIs required for the project are embedding API, extension API, and bootstrap API, which can be implemented using the Java native interface(JNI). JNI acts as a bridge between the java bytecode and a native library like C or Cpp and allows us to call Cpp functions from java and vice versa.
According to Wikipedia there are over 180,000 open-source projects and 1400 unique open-source licenses. Not every license offers the same set of permissions. To know the limitations and liabilities of what an open-source project offers we need to know under what license the project is distributed.
This project aims to solve the problem by automating the detection of licenses. It reads a LICENSE file and makes use of SPDX matching guidelines and string matching algorithms to compare it with the list of SPDX licenses and returns the license(s) present in the file along with the confidence level associated with it.
Currently, caMicroscope uses attribute-based access control, which does not clearly represent the notion of authorization in users and faces performance issues as the database calls are not cached.
This proposal details the implementation of a Role-Based Access Control mechanism, along with an admin panel implemented as a web interface to facilitate configuring the same after deployments. This would ensure a robust method to protect critical resources and data points, and streamline the process of operating with multiple stakeholders. Along with RBAC, to solve the problem of slow database queries that severely impact application performance, a unique method to implement a cache layer that allows minimal chances in the existing codebases has also been described.
The goal of this project would be to develop a web based user interface to visualise the variant prediction data from VEP plugin using the neXtProt tools to make it easily accessible to the users. The interface would be designed in such a way that it is performant, scalable and can easily handle large amounts of data that is computed by the VEP plugin API.
One of the important aspects of searches for new physics at the Large Hadron Collider (LHC) involves the identification and reconstruction of single particles, jets and event topologies of interest in collision events. The End-to-End Deep Learning (E2E) project in the CMS experiment focuses on the development of these reconstruction and identification tasks with innovative deep learning approaches.
This project focuses on the integration of E2E code with the CMSSW inference engine for use in reconstruction algorithms in offline and high-level trigger systems of the CMS experiment.
IMPACT User-friendly QA platform for a given DBpedia resource and specifically about pandemic in real-time.
GOALS To improve the DBpedia Sparql for real-time monitoring of pandemic situations near the users and the interested country by the users. Compile pandemic data and wikidata for answering users' questions by query databases, and support research and development in the healthcare field related to model predictions and vaccine development.
DESCRIPTION As Google engine can answer any question, DBpedia Sparql can query databases and answer questions using Wikipedia resources. The COVID-19 pandemic is an ongoing global pandemic, and humans would need to co-exist with the viruses. We should compile the public wikidata related to coronavirus and learn from them. The aim of this project is to update DBpedia Sparql tool for answering questions related to wikidata and specifically about the coronaviruses. Thus, the improved DBpedia Sparql tool would provide better understanding of the coronavirus pandemic for the public, and serve as a platform for research and development in the public healthcare field.
WARM-UP Git repo: https://github.com/guang-zh/coronavirus_info_app.git
The project aims to sync parts of Open Application Model implementation from KubeVela to Open Application Model Kubernetes runtime. Crossplane is an open source Kubernetes add-on that supercharges your Kubernetes clusters enabling you to provision and manage infrastructure, services and applications. Adding the latest release of upstream specification to Crossplane.
Better resource management in Linux Desktop will help in providing a snappier experience to users by making sure that there is a fair distribution of resources among applications and not processes as has been traditionally followed. This has been made possible by the use of cgroups where applications or tasks can be placed in different slices and allocated resources according to their priority.
The goal of this project is to build upon the current work done and utilize the resource management capabilities provided by systemd. This involves
All of these goals will help in improving the responsiveness of the overall system and prevent one particular user application from hogging all the available resources.
Add the option of using different evolutionary algorithms to the deepbots framework which is a library that facilitates the use of RL on the webots simulator
While GTF files are by themselves comprehensive, a lot of analysis is focused on individual features. For example, any analysis focused on transcriptional regulation would focus more on exons and possibly introns and non-coding RNA than UTRs while translational regulation analysis would focus on only the CDS and possibly the UTRs. Though the GTF is supposed to be a standard format, there are differences in the annotation features for different species.
These analyses often require a BED file to work with. However, currently we don't have any existing database of BED files nor a modular script which can convert GTF files to Bed. Though it is trivial to obtain a BED from GTF but it does require some time.
This project provides a modularized library with an easy to use command line interface to convert GTF files to BED files. It also provides a modular pipeline to create a repository of Bed files for all species on Ensembl. This will save time of great scientists and engineers doing work in this field and maybe they can utilize this time in a more productive way.
The project's main goal is to create a Simulation/Emulation of the CMV12000 sensor currently used in the AXIOM Beta. The HDL could be placed as a direct interface integrated into the ZYNQ design or into a separate FPGA acting as a full sensor emulation.
In this proposal, I layout my strengths in machine learning, open source code and TensorFlow, and argue why I am the best candidate to work with the "Convert Matlab ML examples to Python / JAX" project proposed by the TensorFlow team.
Since BeagleBoards are heterogeneous platforms, why not use them to their full extent? Apparently for the time being the GPU block lies mostly useless and cannot assist with any computations due to non-technical reasons. Normally, OpenCL would be used for accelerating on the GPU, but taking the limitations discussed above it is impossible, yet there is another way! GPGPU acceleration with OpenGLES.
The GPU accelerators from PowerVR (series SGX500) are available in all BB's and a unified acceleration framework for them is the topic of this proposal. The targeted version of OpenGL ES is 2.0, but extending it to the future versions will not be a problem from a technical point of view as the newer versions are backwards compatible. The API of the library will allow for performing various mathematical operations, and will return the results to the user in the same format they input the data in.
Apart from the library, the project will explore the performance gains when using the GPU (compared to the CPU) and provide the user with guidelines on when it is feasible to put the BB's GPU accelerator to use and when to refrain from it.
The idea behind the project is to develop an extension for CiviCRM implementing MJML / GrapeJS for making & sending responsive email newsletters using CiviCRM. This would help user to build newsletters more easily by dragging & dropping approach of responsive web components. Further this extension will help user of CiviCRM to reach more clients through email marketing.
The project aims to use the approach of deep reinforcement learning to create a pipeline for robot control with object grasping and manipulation. Grasping an object is the most fundamental objective of robotic end effectors. Furthermore, every object manipulation task begins with object grasping. The methods deployed currently for this depend on accurate mathematical models of the robot arm. However, the approach this project aims is to teach the arm to accomplish the task on its own similar to how a baby learns to walk or ride a bicycle called reinforcement learning. This can be achieved with either an end-to-end approach (using rgb signals from a camera) or using currently implemented object perception modules (DNN estimated poses). Upon successful development of the workflow, it needs to be tested on a Kinova Gen3 arm.
The Reforestation Assistant & Simulator idea is to create an app to help on reforestation of degraded areas of the planet by drone or manually. The project will consist of an Android App where users can plan the reforesting missions, by defining areas of seeding, specific seed/tree location, drone landing points, fly zones and other helpful metrics. All the gathered information will be dynamically displayed on the Liquid Galaxy cluster using KMLs and also on the app with the help of graphics and text to bring users a great and immersive overview of the mission panorama.
Currently Oppia.org hosts its blog on a separate blogging site, "Medium". I would prefer to have the blogging interface directly on Oppia.org so that it is connected to the rest of the site. This will enable the content of the site to be on one platform altogether. The aim of this project is to add a “blog” dashboard hosted on Oppia.org, that enables its user to create and edit blogs on the website itself.
Virtual desktops look nice with a comfortable environment round them. This project allows the user to use a glTF file as their custom xrdesktop environment and adds more features to the gulkan library to add support for better-looking scenes.
The aim of the project is to implement improve/fix security issues in various OpenMRS Modules. This proposal presents my timeline of the corresponding Action items and answers during GSoC 2021. Security plays a pivotal role to protect users against unintended security breaches and attacks. A polyglot webapplication like OpenMRS has multiple modules written by multiple developers, and the OpenMRS security team has identified potential security issues. Thus it is paramount to ensure that the identified security issues among various Modules are fixed timely. Through this project proposal I present my timelines and work action items with focus on fixing on those identified issues, ultimately ensuring the safety of OpenMRS users.
Scummvm currently has many unstable, incomplete engines like MacVenture, Pink ( Pink Panther ), Avalanche ( Lord Avalot d’Argent ), DM ( Dungeon Master ). My goal for this project is to complete the remaining implementation and fixing bugs of MacVenture engine and Avalanche engine and fixing bugs of DM game engine as an extended target.
Integrate Enzyme into Rust to provide high-performance differentiation in Rust
This project is based on the idea of the simplest form of micro-frontends that we can provide our users with our services like Cloud Registry, TRS, DRS, etc. As TRS/DRS backend services are still in development for GSoC this project is mainly focused on implementing open source clients for the Cloud Registry specifications as Web Components these Components can also be used later for Tool Registry Service (TRS) and Data Repository Service (DRS) specifications by adding the more functionality to these components. This will provide the Microservice~Micro-Frontend architecture to the organization.
As it stands today, S3-tests uses a limited fraction of the Boto S3 functionality. By instrumenting code coverage of Boto SDKs and s3-tests, gaps in S3-tests can be identified.
The aim is to write new tests that attempt to cover all lines of various S3 SDKs to test compatibility issues by identifying parts of unused code using code coverage tools. We will try to implement S3-tests by leveraging code coverage for as many S3 SDKs as possible.
Mentor : Robin H. Johnson
I will develop and publish a Linux application named FastFingers which will be an open-source application that helps its users to remove the habit of using a mouse, by helping them to memorize the shortcuts they want to learn.
ZT (zulip-term) is a TUI-based Zulip client that allows users to chat with each other right from their terminal window, with minimum possible tools. In this project, I shall focus mainly on improving the User experience for zulip-terminal. Currently, there are some features for which a user tends to switch to the Webapp counterpart. In addition to this, the goal shall be to fix up major issues in the issue tracker, improving the test suite, refactoring code, and adding new features.
QEMU already includes a basic implementation of the virtualization extensions that are found in AMD processors. This implementation, however, is not complete and contains several bugs. The project's primary purpose is to complete the AMD virtualization emulation. The project includes:
(https://wiki.qemu.org/Google_Summer_of_Code_2021#Complete_AMD_virtualization_emulation)
The Heavy Flavour AVeraging (HFLAV) group is responsible for collecting and combining measurements made at different High Energy Physics (HEP) experiments, at CERN and other particle physics laboratories, and combining them using robust statistical procedures. HFLAV averages are published periodically in peer-reviewed publications and journals.
The HFLAV website provides a live snapshot of the latest data obtained from these latest publications. This project aims to improve the experience of users using the HFLAV website. These averages could be of greater value to the particle physics community if the accessibility, interactivity and visibility of the current website can be improved. Thus this project seeks to transform user interaction with HFLAV’s ‘Beauty to Charm’ averages.
The plan to increase the accessibility is by redesigning the whole user interface, making it easier to find a relevant data point ( branching fraction). Interactivity and visibility will be increased by allowing the user to pick experiments according to their requirements and allow them to find their averages in real-time. This requires a change in framework of website from a static app to a Django app.
My GSoC project in 2019, on the Adaptive Cloth Simulator, was an exploration in adding support for parametric on-the-fly remeshing for Blender's Cloth Simulator in order to provide high-resolution-equivalent fidelity at reduced computational cost. During GSoC 2021, I will utilize the insights gained, as well as previously fleshed-out core ideas, to stabilize this feature for production. This will involve introducing a new mesh structure, fixing bugs and regressions, refactoring to integrate well with the latest Blender updates, etc. As a stretch goal, I would improve Blender's cloth caching system to introduce support for Adaptive Remeshing.
Add support for extended operations in FHIR , namely the $lastn and $lastn-encounters on the Observation resource, and both the type level and instance level $everything operation on the Patient resource
Expanding on ideas developed during previous iterations of R Community Explorer (https://github.com/benubah/r-community-explorer), which was responsible for enhancing the visibility of R User Groups and R projects developed during GSoC, this project intends to use Twitter, a social network that serves as possibly the largest gathering of R users, to retrieve data and develop interactive dashboards that can lead to better analysis of engagement during conferences and meetups, better visibility of key people in the R community and also identify rising trends in the R programming ecosystem.
This will be done initially through two dashboards, one for analyzing the most popular R Twitter hashtag (#rstats) and other that will analyze information regarding the useR! 2021 conference, happening in early July. These initial dashboards will serve as a background for the development of a template repository, which will allow potential users and conference organizers to develop their own Twitter-based dashboards, which can hopefully help by providing insights to their own projects and guide data-based decision making.
The goal is to develop a standalone Brick Library (own library/repository; mutually understandable by all major projects in the organization, which utilize the Catrobat Language and its bricks) as need for functionality in Catblocks and Catroweb.
Other objectives of this project are the streamlining of brick construction via Construction Patterns, which in turn will massively improve testability, maintainability of code and usability (on the programmers side, it will be easier to implement new bricks, and harder to make mistakes while doing so) and synchronizing Cross-Team Brick changes/updates and new bricks can easily be propagated throughout the whole organizational structure (with just 1x git pull) as well.
This includes the creation of a new Brick Definition Format, the transcription of all existing Bricks into the new Format, "teaching" the new format to Catblocks and Designing an Example Brick Creation Pattern for Pocket Code for Android for a first set of bricks as an extendable Proof of Concept.
In the current version of Pocket Code, users have to manually click and scroll through all brick categories and bricks to find and add the desired brick to their project. Therefore a brick search functionality will be implemented which enables the user to search through all available bricks in all brick categories. The matching bricks will be shown to the user and can be added to the project. This will provide a more improved programming flow for users of all skill groups. If there's time, a similar search & complete feature can also be added for reporter functions and sensors, and even variable or look names in the formula editor.
Shaka Player provides multiple configuration options for developers to decide which information, buttons, colors and many other parameters are displayed in the user interface at an app-level.
This project aims to expand the functionality of previous existing buttons, add a new one and enhance what the user experiences when interacting with the player!
Practically, the complete development includes completely resolving the following active issues:
Let us take a step forward on Shaka Player’s User Interface!
🎉📺🎥
The project aims to implement IPv6 Nix-Vector Routing with minimal code duplication from IPv4 Nix-Vector Routing.
ns-3 has an implementation of Nix-Vector routing for IPv4. Routing protocols like Global Routing and Nix-Vector Routing help the user a lot when dealing with complex topologies. Unlike any dynamic routing protocol, these protocols simply fill the routing tables and prevent any overhead involved. Currently, there is no such implementation for IPv6 available in ns-3. For IPv6 Nix-Vector Routing, the implementation should handle link-local and global unicast addresses.
This proposal provides the user with the ability to invert the colours of the Score Page itself (along with all contained components like Time Signatures, Clefs, Barlines, Notes etc.)
The project idea is focused on creating integration test cases using Gherkin language to take care of creating laboratory environments using virtual machines. Aims to provide an easy way to create integration tests for Ceph orchestrator.
Red Hen OpenDataset contains annotated gesture videos from talk shows. The project requires to systematize the data for computer science researchers and develop deep learning models as classifiers on the video dataset.
The goals of this research project will be as follows:
The objective of this project is to build a pipeline for decentralized (IPFS) storage of BIDS-compliant neuroimaging data, with support for version control and authentication through signatures associated with Decentralized IDs (DIDs).
This project’s primary goal is to integrate jabref with Microsoft word using an office add-in. That will allow users to speed up the process of referencing when writing, giving users the tools to quickly and easily insert references from their library directly into their word documents.
The overarching goal of the project is to have a minimum viable project which can compile the dftatom project which is of personal interest to me as a computational chemist. Following through with the initial contributions I made fulfilling the patch requirement, I shall work towards the completion of the math library. In particular, I intend to complete the tasks for the new Fortran runtime library. To be pragmatic and get an MVP, I shall work on allowing LFortran to use externally compiled modules. Subsequently, I shall work on the implementation of arrays and their intrinsics and round out the project by enumerating all remaining corner-cases required for the dftatom project.
Curves in blender have been subject to a number of user requests for improvement from several different aspects. One such request was a new tool that makes the workflow for dealing with curves much smoother by enabling the editing of curves using simple and intuitive shortcuts instead of taking multiple steps to achieve the same. Another suggestion was the ability to create bevels at bends of a curve. The goal of this project is to address and develop solutions for these suggestions.
I would like to work on creating dataflow operations which users can use out of the box for their data cleanup tasks. All the cleanup operations can be chained together so that users can directly plugin the data clean up operations that they would like to perform in a single dataflow, the input to that dataflow will be a dataset from some source and the output would be cleaned up data.
I would also be creating plugin for the sklearn metrics methods for the accuracy type plugins, using which users will get many types of accuracy scorers for their models. As there are many evaluation methods of a model, using many other accuracy evaluation methods the users will be able to make an informed decision about their models.
Deep Learning continues to be a key application for a range of services nowadays - from autonomous vehicles to data centers and even in embedded applications. The core operation in these Deep learning architectures are fused dot products and matrix multiply. Owing to the huge memory and compute demands of these applications, multiple approaches to speed up or optimize deep learning operations (like Conv2d, FC, etc.) have been proposed such as using GPUs, creating custom accelerators with their own specific dataflows (like TPU, Eyeriss) or creating custom ISAs. This project takes a slightly different take on the matter. The objective is to add a tensor core extension to a RISC-V processor like WARP-V to create a custom RISC-V ISA design to accelerate Deep learning workloads.
The Wikisource Pagelist Widget is an OOUI based widget that streamlines the process of creating a pagelist for new (and existing) Wikisource users. While using the Pagelist widget, the user is presented with the picture of a scanned page and is asked to identify the page number on the scan. However, there is no option to zoom or pan the scanned image inside the Pagelist widget. Adding the option to zoom and pan the image will allow users to see the page number for scans that have a tiny font or have lots of text (for example, newspapers scans).
Fossology's copyright detection agent uses a rule-based approach to detect copyright statements but the agent is showing a lot of False Positives result. The way proposed to get better accuracy and results is by using ML techniques it. The most likely way is using NLP for data pre-processing and then making a Knowledge Base Relation corpus on top of which we can apply different ML algorithms and can improve up the accuracy. Applying checks on a different level and limiting down a statement to only the part where only the copyright statement is present will definitely help in reducing the False Positives.
Enable users to attach a script or Lua function to a watchpoint and execute it when the program flow hits it in LLDB and improve the whole documentation for Lua scripting in LLDB.
A Java and Retrofit2 based library, which mainly focuses on building an abstraction layer over the fineract API. Currently, all the MIFOS application uses fineract API and has a lot of repeated code for API integration hence the main motive of this project was to eliminate the boilerplate API integration code and provide an SDK with proper and comprehensive documentation so that it can be easily integrated with all the MIFOS's front end application. This summer I will be spending most of my time automating the steps that are currently used for generating API. Some of them are creating templates, publishing documents, improving CI/CD, etc. Apart from that this year's end goal is to release the SDK for fineract 1.4.0 or 1.5.0 whichever the latest is until then.
OpenCV.js exposes JavaScript API of dnn module that allows web apps to do deep learning model inference in web browsers. This capability enables web developers to create intelligent usages, like image classification, object detection, segmentation and style transfer, with rich web contents, like images, videos and camera streams. Although OpenCV.js dnn module is using WebAssembly with multi-threading and SIMD128 optimization, there still exists a huge gap between OpenCV.js and OpenCV native. This is because OpenCV native can leverage more advanced hardware features and even ML-specific accelerators via native instructions and ML APIs. Web Neural Network API (WebNN) is an emerging web standard that allows web apps to access the AI hardware accelerations. It can get near-native performance on a variety of Intel-based platforms through the open source module oneDNN. Thus, in this proposal, I illustrate my idea about how to integrate WebNN into OpenCV.js and accelerate dnn module.
Implement gearwork and communication interface with high speed read and write for multiple eMMC's
Fractal stands on the brink of adapting new technologies. With the release of GTK 4, the evolution of Fractal’s new foundation – the matrix-rust-sdk – and discussions about its maintainability, a lot of changes became necessary. So much so, that the Fractal developer community decided to regard the existing Fractal code base a liability and start over freshly.
The new clean-slate approach is called Fractal NEXT and I will use this year’s GSoC to help bring it to fruition. This project will move Fractal NEXT from a bare-bone prototype to a basic but very functional Matrix client by implementing main features that are in the daily loop of any Fractal user.
The idea is to organise each of the solvers into a class with a consistent interface. Then the main part of dsolve can loop over these classes rather than having a monolothic matching function.
This will make the code easier to maintain and understand and eliminate the need for global variables.
This can also make dsolve much faster. Currently all the matching code for all of the methods runs for every ODE before a solution is returned. Some of the methods can return a solution much faster than other methods can run their matching code. Once everything is neatly organised into classes the main match and solve code can be changed to return the first solution that matches.
Testing is vital for quality coding. It not only makes the code more consistent but also ensures that any addition of new code won’t break the existing one. This project aims at making the testing for p5.js-sound library more robust, more appealing to the user, and adding more tests for future code easy and fun!. project in idea list
Project scope is to develop a React.js library of pedigree components that will meet the GA4GH standards. Library will be build of accessible components. On top of that, library will include a environment to run components and speed up the development process.
Due to need of building tools from those components, library will provide an API to make it easier for developers to modify state of components from code level. Components are still accessible from library without any abstract layers or boilerplates so developers have freedom of choice, how to build their app.
Create an overview of OpenWrt supported devices to simplify user choice of acquiring new devices
Tarantool uses SQL VM with conventional interpretation technique: loop over instruction, inside which dispatching switch-case executes logic of current opcode. Beyond introduction of JIT to SQL subsystem there are multiple smaller improvements which might be developed for SQL virtual machine:
IntelOwl is an Open Source Intelligence (OSINT) solution designed with the intent to help the community to get threat intelligence data about an observable such as a specific file, an IP, etc from a single source at scale. One of the strongest limitations of this project is the lack of built-in integrations with other widespread open-source CTI platforms such as MISP and OpenCTI. I propose a new component of the project - a connectors manager which would help connect IntelOwl with any external tool for be it enhancing the data it generates or performing automated analysis on the data it generates; or those which would facilitate the integration with other threat intelligence platforms. Along with this, I would also add the integrations for MISP and OpenCTI which the community has been eagerly waiting for.
Help to develop the Macromedia Director tool.
This project would speed up string formatting and many other frequently used operations in mypyc. We also add byte and related operations support.
This proposal aims to add support for directly differentiating functors and lambda expressions and increase clad coverage and overcome its shortcomings by fixing various existing issues and adding support for various currently unsupported syntax.
eeDAP is an evaluation environment for Digital and Analog Pathology. The software has two modes one for digital WSI image evaluation and other for realtime comparison of analog image and digital WSI image. The key features or process of the eeDAP have to be developed such as the registration of the digital and analog images. The registration is done by the study administrator to get the relation between WSI image coordinates and x-y stage coordinates. This project aims to develop the interface to do the local registration and global registration and compute the transformation bias. This will be incorporated with the existing camicroscope code base and added as a plug-in to control the microscope stage movement and lens selection so that comparative analysis of digital WSI image and real-time microscopic image of the same sample is possible.
Algorithmic approach to automate the process of adding hyperlinks of archived books to Wikipedia pages in an attempt to drastically simplify and alter the form of manual labor, if not completely reduce it.
DdiMon is an introspection engine capable of hooking PatchGuard in Windows using shadow EPT style hooks. Specifically, it hooks the execution of specific kernel level function calls, while using EPT to prevent the guest from seeing or being able to modify these hooks.
This project will port this capability to the Bareflank hypervisor to create an example for educational purposes. Like DdiMon, the results of this project will provide the user with the ability to hook and monitor PatchGuard for Windows. In addition, this project will extend this capability to the Linux operating system. Specifically, the student will identify key kernel level functions within Linux to hook and monitor, similar to the Windows variant, demonstrating the ability to monitor the execution of the Linux operating system without detection.
Finally the results of this project will be well simplified, tested, documented and upstreamed to the Bareflank hypervisor project as sophisticated example, which hopefully lowers the entry barrier for further contributions and leads to more projects getting implemented on top of Bareflank.
This proposal consists of two projects:
Review Tracks Through CritiqueBrainz: ListenBrainz should allow users to write short reviews for tracks, release groups, and artists directly through our website using the CritiqueBrainz API. This project aims to drive increased contributions of reviews to CritiqueBrainz by making it easier to submit them.
Pin Tracks: This project aims to allow for ListenBrainz users to pin their favorite recording to their profiles with a short blurb. This feature will allow users to get a better idea of what kind of music their following circle is interested in and make user profiles more personalized.
The main goal of this project is to provide a new back-end for TACO, that generates LLVM bytecode instead of C code, using the LLVM C++ API to do it. The main benefits of outputting LLVM IR are enabling optimizations at the LLVM IR level and to target any machine code available in the LLVM framework, including NVPTX.
Left Over Time:
Histograms in databases are compact summaries of the data distribution in a column. They are usually used by the query optimizer on non-indexed columns to produce efficient query plans, which then determine how many rows are read during query execution.
This project aims to:
The idea behind this project is to add new features and functionality that complement the R Calendar of R Community Explorer. This project presently lacks the R related Events Exploration functionality. As tracking these events are very much necessary to learn the trending ideas within the R community and conversations on the new technologies. It will help current and potential users and developers to accurately access growth trends and new technologies.
The implementation of Events Exploration will help the R community to understand who are regular and most frequent types of R events organizers globally. In which region the events are organized and what are their topics of discussion. The trending topics in these events, so that the whole community can also study and contribute in this chain.
digiKam 7.2 as of now, is fully compatible with Qt 5.15.2 on all major platforms. Qt6 has been released recently. Given that Qt5 and Qt6 are 8 years apart, the way of doing things has changed and complies with the C++17 standard. This project is aimed at preparing the digiKam project to be ported and released with Qt6 on Linux. Implementations that rely on deprecated, removed, improved APIs will be ported with a lot of regression testing.
The AppImage is known to be broken as it doesn’t support internationalization, or proper ICU support. ICU works fine on other sources for digiKam like flatpak and native binaries. This issue will be fixed by porting the AppImage builder scripts to use Qt 5.15.2 with KDE Patches collection (Not for the moment) which was recently announced (https://dot.kde.org/2021/04/06/announcing-kdes-qt-5-patch-collection). New scripts will be implemented to build the AppImage with Qt6 in future.
This project aims to improve the statistics part of kw, adding more options, and also implementing a way to let users, who choose to, take part in a public survey by sharing this information.
This Project looks at creating a data source for querying the Ethereum Blockchain. It will use the JSON-RPC interface provided by Ethereum to access it. It will create a predefined schema that will map to the various data structures of Ethereum like blocks and transactions. It will allow to go through the transaction specified in the chain and look at details about the blocks. We will also implement a caching system for the blocks to have fast access to the blocks and avoid redundant calls to the JSON-RPC.
The main idea behind the project is to build a plugin to automatically determine the next semantic version for a repository. As the CI/CD world is moving more towards complete automation and minimal human interaction, the ability to fully automate a release, including the determination of the "next" release version becomes desirable. The proposed plugin does exactly that. Taking in various sources of input and git commit and tag history of the repository, it outputs the next semantic version or the next release version.
The project aims to migrate all the JS\TS linter checks written in python using raw parsing algorithms and regex pattern checkers to custom eslint rules. The migration is going to affect developer experience in the following ways:
Radis is a fast line-by-line code used to synthesize high-resolution infrared molecular spectra and a post-processing library to analyze spectral lines. It can synthesize absorption and emission spectrum for multiple molecular species at both equilibrium and non-equilibrium conditions. Radis uses two methods for computing Spectrum that are Legacy and DLM.
The goal of this project is to derive an equation (R) comprising of all the parameters that can affect the performance for calculating Voigt broadening by running a number of benchmarks for different parameters involved in the calculation of lineshapes to check their significance in computation time. Then we need to find the critical value for the derived equation (Rc) which will tell us which optimization technique to select based on the computed R value in calc_spectrum().
We have already moved from Postscript to PDF as the standard data format for print jobs. Michael Sweet has deprecated the use of PPD files, but due to lack of replacement, we have continued using them. Some years ago the concept of printer applications as a replacement for the classic CUPS printer drivers was introduced. It solves many problems including no more use of obsolete PPD files and it enhances sandboxing. Printer applications themselves can be sandboxed, so they can be distributed as OS-distribution-independent packages on a central download place. For this, all filter functions also need to work correctly even if there is no PPD file assigned to the print queue. They should as well understand standard IPP attributes as their options and printer IPP attributes for their default settings.
The supercore, also known as score provides services for all APIs and for the core parts of RTEMS, there is no automatic checking of the coding style. Therefore for people new to RTEMS, it can get tricky to get it right when sending patches. This project will work towards automatic style and formatting checking for RTEMS score. By doing so, it will be able to tell if patches need changes before being sent for review. This project is aimed at creating a tool for automatic style checking of RTEMS. It will be achieved by firstly finding a code checker or "formatter"(clang-format) that matches RTEMS’ coding style, writing a script built into git commit hook that can run over patches before committing or submitting via email, as well as creating a standalone tool in rtems-tools to run over the entire codebase checking for any mismatches in the coding style. A script similar to checkpatch.pl of Linux will also be added to check whether patches will need changes before being submitted. The goal is to find a combination of clang-format settings combined with changes to the RTEMS style and changes to clang-format such that the output with the right settings matches the RTEMS code style.
Package volesti supports volume estimation for polytopes, providing several randomized approximation methods. The most efficient implementation employs billiard walk (uniform sampling) and a certain Multiphase Monte Carlo technique. The project is about extending volesti to support uniform and gaussian sampling for spectrahedra. Moreover, we will extend the volume estimation methods to support spectrahedra. Spectrahedra are probably the most well studied shapes after polyhedra. They are the feasible regions of semidefinite programs in the way that polytopes are feasible regions of linear programs. Thus, the project is of special interest for the research communities of geometric computing and optimization.
When novice users use DBpedia for querying, the information they really want is always overwhelmed by numerous query results. In this project, we want to leverage the Knowledge Graph of DBpedia to develop a graph-query tool that can help the end user to obtain relevant information w.r.t his request/input/query. We can give the users a subgraph where the concept/entity that students query for is center and it is surrounded by its most important concepts (like the top-5 or top-10, in terms of the Social Network Analysis measures).
The project focuses on removing the unused CSS and fixing/improving the developer tooling area.
The project is marked as Issue #169 in GitHub. The main goal of this project is to visualize the network which is generated from the Casual Path algorithm using some of available functionalities of cytoscape and make an executable jar file which is a cytoscape application for visualization of the generated network and also store the previous used files and save the current session for future reference. I have written detailed overview and implementation approach for the project and create a timeline for the whole implementation.
The project mainly concentrates on automating the module site for collecting information about modules from all over Terasology organization and display their generated information on the module site it also focuses on migrating the web presence and it will include working on frontend layout and improving the UX and UI of the module site.
Provide the ability to upgrade to a new version of gtk, replacing deprecated ones with modern equivalents.
LLVM’s attributor framework is a fixed-point iteration framework that was originally designed to deduce attributes of objects, such as whether or not some function will always return. During its initial phase, the attributor seeds all attributes in the intermediate representation (IR). Seeding all attributes may not always be necessary to reach a fixed-point and reducing the number of attributes can also reduce the runtime of the attributor pass. The latter will become more important in the future as new attributes are added.
In this project, we want to create a machine learning model that learns seeding heuristics in order to reduce the attributor pass' runtime without sacrificing its deduction capabilities.
This Project aims at extending the cilium config command which would expose all the active configurations in the cilium-agent. It also aims at improving the cilium-agent by adding subcommands such as cilium encrypt status and cilium encrypt commands
The project primarily focuses on creating a flutter-based native mobile interface for Flood ( https://flood.js.org ) which is a web interface wrapping over torrent clients like rTorrent, qBittorrent, and Transmission. The main idea is to use the existing API and provide the users with a native mobile experience while still having all the fundamental features and keeping room for plugins (Shoutbox etc) to enhance the feature set with maximum code reusability.
Having a native mobile app would also allow the use of platform/device-specific functionality like actionable notifications, snack bar, modal bottom sheet, swipes to delete/archive, etc. which would enhance the user experience.
The aim of this project is to create a bot for Gerrit that would use haiku-format tool for checking whether the patch submitted follows the community guidelines of Haiku and post the report in the comments. The architecture will include the existing concourse CI and Gerrit review tool and their interaction using REST APIs.
This is a proposal for no. 15 project idea - "Webots integration with RoboComp". As the title indicates, the project aims at integrating RoboComp with Webots and making it possible to open simulations created in RoboComp on Webots simulator. To achieve it we need to get very good understanding of the .proto and .wbt extensions made in Webots and somehow reconstruct the logic from RoboComp to make it understandable for Webots. We can do that using Python classes and objects to interact between the files and programs.
Social Street Smart extension provides some basic functionalities like labeling social media posts as clickbait, fake news, etc., on three platforms: Twitter, Facebook, and Reddit. Still, it needs new features to create a significant user impact. This project aims to develop a Chrome Extension to make the Internet a safer and more effective service for the users, hence needs lots of user-friendly features, which makes browsing social media a safe experience. For this project, I would improve upon existing features, add a few new and enable user interaction for the first time. During the GSoC period, I would add new features while ensuring a solid, bug-free, non-glitchy smooth, flexible, and easy to use and maintain code architecture.
Rucio is an open-source software framework that provides functionality to scientific collaborations to organize, manage, monitor, and access their distributed data and dataflows across heterogeneous infrastructures. Rucio was originally developed to meet the requirements of the high-energy physics experiment ATLAS and is continuously enhanced to support diverse scientific communities. This project seeks to enhance Rucio clients primarily by enabling the availability of different transfer tools to make them easier to use in heterogeneous environments. This project aims to implement protocol support for SSH, rsync, and rclone, along with the ability to choose the optimal transfer protocol based upon the local and remote configuration, unless specifically mentioned otherwise.
JAX as the latest machine learning library has all the advanced gradient techniques aided by acceleration of GPU/TPU and high-level modules for model prototyping.So it definitely is a faster alternative to numpy as it can use XLA engine and the JIT compiler.
The book “Probabilistic Machine Learning: An Introduction” is an amazing book for any level of machine learning enthusiast and the examples mentioned in the book are very accurate and helpful in analysing the ML algorithms and tools.
Building a pipeline to classify EEG data
The web interface of Kodi was originally written in Coffeescript and had to be re-written in Elm for maintenance purposes. Till now a basic layout of the web interface has been made and adding some features and styling is left. With this project we aim to complete the Elm-Chorus web interface by adding the remaining features from Chorus-2 and also adding some additional features and design along the way.
This project aims at integrating GPU accelerated FDTD sub-gridding into gprMax. The current version of gprMax treats everything within the same spatial resolution but every region may not need such fine discretisation. Hence, Sub-gridding helps to improve computational time as well as modelling of a real-world problem (Beillard B. et al., 1998).
ChemoSpec is an R package for analyzing spectral data that arises from chemical and physical processes. ChemoSpec uses base graphics with one exception in which lattice graphics are used, and another instance in which the D3.js JavaScript library is used. The base graphics system of R produces very nice, publication quality graphics (at least under the right conditions), though customizing base graphics requires many lines of code. This proposal aims to provide an additional interactive graphics system for ChemoSpec where the users will have the option to choose the type of graphics output.
This proposal is to revamp the current Styles deck sidebar for the original Styles Highlighter project
Multi-task learning shares information between related tasks, reducing the number of parameters required. State of the art results across natural language understanding tasks in the GLUE benchmark has been previously used transfer learning from a large task: unsupervised training with BERT, where a separate BERT model was fine-tuned for each task.
In the current state of the DeepPavlov, multi-task BERT is implemented in Tensorflow which need to be refactored such that DeepPavlov uses new frameworks such as PyTorch. The refactored code also needs to incorporate techniques such as PAL-BERT, CA-MTL, MT-DNN within the DeepPavlov library by matching the results of the GLUE benchmark on the respective techniques.
I strongly believe that along with providing better functionality to the current audience, this project will help the audience of DeepPavlov.I want to get more involved with projects like DeepPavlov as it helps me become a better software engineer. It is always great when to see your code being used and appreciated by people.
In GSoC 2020, The TFLite team and I released the TensorFlow Lite Support Suite consisting of TFLite Flutter Plugin, TFLite Flutter Helper Library, and a couple of example apps with tutorials. The project is receiving excellent comments from the community, as they are finally able to build performant Flutter ML apps with models and TF versions of their choice. The recent release of Flutter 2.0 should attract even more users. This year, we plan to extend the TFLite Flutter Support Suite based on the users' feedback and latest developments in the TensorFlow Lite ecosystem.
TFLite Flutter Plugin will be improved for better handling errors and supporting more platforms along with Android and iOS.
TFLite Flutter Helper will be updated to match developments in its Java counterpart.
Flutter Task Library based on the TFLite Android Task Library to provide out-of-box support for popular use cases like detection, question, and answer, etc. The Flutter Library will leverage the performance and capabilities of the C++ Task APIs through dart ffi bindings. Example apps to demonstrate the usage of Task Library.
Time-series analysis is a broad, interdisciplinary field, and features for analyzing time-series datasets are ever-increasing. This has led to creating an online Django platform, CompEngine-Features, for comparing new time-series analysis features with an existing set of over 7000 time-series analysis features in the hctsa package. However, the platform lacks: support for incorporating new features contributed by users, client-side rendering of web pages, network visualizations, line plots for Empirical1000 dataset, and async views in Django, all of which are crucial for the adoption of the platform and thus its ability to have a significant impact in driving progress in time-series analysis. In this project, we will continue developing a Django online platform, CompEngine-Features, for comparing the performance of time-series analysis methods on real time-series data, including a wide range of neural dynamics.
In the last GSoC, kingiw created an initial version of casbin.js. This version has a CASL-like API. He also adds support to go-casbin and node-casbin.
However, casbin.js relies on an insufficient way to share permissions between the frontend and backend. The backend needs to send the whole policy definition model to the frontend, which will use node-casbin to check the permission. This method requires a heavy data transfer in between, and has potential security problems.
To build a production-ready frontend permission control library, we need to
I will improve spdx_python_licensematching significantly. The goal of this project is to enable softwares such as scancode-toolkit or package managers to use this matcher as a library.
Here’s my plan, ordered by priority.
MetaCall Core is an open-source software that brings the polyglot programming experience to Developers. With MetaCall, developers can embed different programming languages through an easy-to-use high-level API. Jupyter Notebook is an interactive environment that allows scientists, researchers, developers and engineers to perform analysis, scientific computing, code prototyping and more. These notebooks provide a feature-rich interface where they can capitalize on visualizations, figures, plots and user-interface elements to prototype the code they are writing and working on.
This project aims to create a kernel where the MetaCall Core can be loaded and launched through a Jupyter Notebook interface. With this Notebook, the users can try out writing and embedding code in different programming languages. It would also make it possible to use the MetaCall API and achieve the goal of bringing a unified interface for developers to try out and leverage MetaCall. The Kernel would allow developers to load the MetaCall API to execute code in different programming languages by mixing code amongst each other.
In this proposed project, we focus on the subpart of Free Modules of Finite Rank. We divide the project into two phases. In Phase I, we focus on using existing libraries such as numpy.ndarray, to revamp current implementations of tensor calculus (as proposed by Prof. Koeppe in tickets #30308 and #30096). Extensive unit testing will be implemented on tensor calculus with new backends. In Phase II, we propose to extend SageMath’s ability to perform computations with tensors via the Tensor Train format, which locally forms an embedded Riemannian Manifold if the Tensor-Train rank is fixed [Holtz et al.], yielding a free module with finite rank. Furthermore, Theorem 2 proves that its tangent space admits a unique characterization up to insertion of orthogonal matrices. High-dimensional numerical methods often rely on finding an Ansatz in the identified tangent space in order for the TT format to not grow prohibitively memory-demanding (for low-dimensional approximations [Holtz et al.]); the convenient mathematical representation of TT decompositions creates a possibility to use Sage as a backend to study the geometry of the nonlinear manifold unique to an applied problem.
Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework, used in many particle physics data analysis and applications. A fast inference system that takes takes ONNX model as input and produces compilation-ready standalone C++ scripts as output is under development in TMVA. This project will focus on the development of ONNX RNN, LSTM and GRU operators in the code generation format.
SenZ is a new kind of query language that can be used to communicate with IoT devices. It is easily integrable, incredibly fast, and is in the highest end of security integration. The aim of this project proposal is to enable real time data flow among the registered clients, enable sharing of large video files among the registered clients and allow seamless integration of external services.
Optimizations have been the cause of multiple miscompilations as well. It is difficult to determine whether an optimization is correct because bugs occur in corner cases and it’s hard to test them all for each optimization. But, thanks to Alive2, we can formally check the correctness of optimizations. Many of the bugs found are related to the notion of undef and poison values in LLVM. The semantics of these values has been formalized recently, and existing optimizations are being fixed to match the semantics. For example, branching on undef is now defined as undefined behavior (UB), and several branch-related optimizations are being fixed. However, fixing some of the optimizations requires further work, mainly due to performance concerns. One representative example is loop unswitch: it is incorrect, but still unfixed because fixing it causes big regressions in some benchmarks. Our goal is to fix such miscompilations with minimal-to-no performance regression. This project will investigate what is necessary to recover slowdowns and upstream the patches to LLVM.
Robotics-Academy currently has the single robot Amazon warehouse exercise implemented for the gzweb version. I plan to accomplish the following over the summer: Construct a RADI for ROS2 Foxy; Extend the warehouse exercise to the web-based template; Explore improvements in reference solutions for the exercises
My goal is to create a series of examples using the p5.xr library that show people how to work with creative coding concepts inside of virtual space. I’m interested in learning how XR can be used for artistic ambitions and sharing what I learn with others by making examples with typography, interactivity, and embodiment in virtual space.
To expand SFK labs impact I propose, inspired by the project authors, the addition of a component that allows the user to visualize the source code of the current lab and via an embedded text editor, and interactively play with a sandbox environment that allows for code fixing and testing. The users are provided with the ability to not only exploit the vulnerability, but visualize the underlying source of the security issue and attempt to fix it. This fixing feature verifies the user solution for inconsistencies in syntax, and after proving that the service won’t be crashed by the changes, run the newly modified version overriding the original one. In this way we enable the user to dynamically test for the secure code fragment that fixes the root cause of the issue exemplified in the lab.
I listed three potential projects, the main directions are implement MLCV research papers with GPU CUDA accelerating and distributing API, and code examples with tutorials on Colab. I would like to do any one direction (implement more) or two directions (which works can be supplement and adjusted models for more improvement). ; For CUDA C++ accelerating, my current ideas are concurrency improvement (on host) and parallel and shared memory improvement (on device), and I open for urgent project of Eigen's Module. For develop core code examples, my current ideas are implement the most popular models such as Mask R-CNN, Fast R-CNN, YOLO etc, include example code and visualization tool), and also interested in development the GPU accelerating distributing API. For the TF model garden, my current ideas are implement the models listed in the Project2 or other new research paper by TF on Colab notebook.
The performance of the code generated for the GPU heavily depends on runtime parameters such as the number of thread blocks and threads per thread block. For this reason, a proper choice of such parameters based on both the IR information and runtime information can give a tangible improvement of the performance of the generated code. In this project, we will explore the ML-based approach to this problem which uses machine learning models for making a decision on the runtime parameter values given the IR and runtime features.
UNU.RAN is a performant C library with methods to sample from continuous, discrete, multivariate, and empirical distributions. It has been used by CERN in its ROOT project and an R interface called Runuran also exists. It will be a very nice addition to scipy.stats. The default method used by SciPy to sample from any distribution requires integrating the PDF and then numerically inverting the CDF. The implementation in SciPy is too slow to be relied on for practical purposes and custom methods for sampling random variates need to be implemented for the distributions in SciPy. In contrast UNU.RAN offers several methods (e.g. TDR, PINV) that offer very good performance to sample from wide classes of distributions.
The goal of this project is to provide an object-oriented interface for methods present in UNU.RAN to sample from univariate continuous and discrete distributions using NumPy’s BitGenerator as the Uniform Random Number Sampler (URNG). My proposal also includes writing a comprehensive test and documentation suite with tutorials. If time permits, I also propose to write benchmarks for the added methods.
The Fineract-cn-mobile application is the Android client of Apache Fineract CN, built on top of the FIneract CN Platform. It provides banking solutions for people around the world who are unbacked. This app is for field officers who go to their customers and provide them with financial services.
This time we are planning to work on some functional Improvements in Fineract CN Mobile mobile application. One of the major functionalities that we are looking forward to implement is Integration of Payment Hub to enable disbursement via Mobile Money API. We also look forward to extend the offline first approach to Ledger, Teller, and Account Screens, using Couchbase Integration. Further, We look forward to make major enhancements in the Teller and Account sections. We also aim to improve the GIS features in application. Work will also be done on UI/UX to improve the overall aesthetics of the Application.
CHAOSS metrics have been defined to provide an in-depth view into the various features of an open-source project. The metrics are also a key input to help organizations strategically invest their resources.
The main aim of the project is to understand the metrics release process, propose process improvements and automate the release process of these metrics.
In addition to the original English version of these metrics, these metrics are also translated into different languages to help communities across the globe understand and benefit from them.
By the end of this project, there would be complete automation in the process of generation of reports for the metrics and their translations
When dealing with time series, sometimes the trend in a signal seems to suddenly change at certain points. In many disciplines it is important to identify these changepoints in order to obtain useful information about the dataset. There are several techniques designed to accomplish this task. Among them, Binary Segmentation is an algorithm that computes changepoints in linearithmic time. Although the predicted changepoints are approximated, it is widely used since it is fast and efficient even for large datasets.
The aim of this project is to create a new package that implements the Binary Segmentation algorithm with support for several distributions and types of change. The algorithm will be implemented in C++, by using an Object Oriented approach to create an easily extensible structure, and it will be integrated with R via Rcpp. This will be useful for usRs with large datasets who want to obtain a quick segmentation model.
Even though the Binary Segmentation algorithm is useful, it has a couple of shortcomings. As a stretch goal, the package will implement some modified versions such as Seeded Binary Segmentation, as well as include support for penalty functions.
The main goal of this project is to build a new template and a backend architecture running on a docker container for visual detection exercises. More specifically, it revolves around building a template for visual detection exercises(e.g. Human pose estimation or traffic sign recognition), which must be solved by providing a trained model for the particular exercise. In this way the user would have to upload a trained model through a user-friendly web template, the model must match the defined set of inputs(e.g. Single or multiple images) and outputs(e.g. 2D coordinates). This would help replace the previous requirements of manually coding the behavior of the robot. Finally, we would also be building new exercises in the Robotics Academy which make use of this new paradigm.
Around 100 PB data is generated from CERN experiments every year. EOS is a disk-based storage service at CERN. This massive amount of data is sent to EOS, gets reconstructed, and becomes smaller analysis datasets that physicists can easily analyse.
SWAN (Service for web-based analysis) is an interactive data analysis platform that allows data analysis using only a web browser. CERNBox is a sync and share cloud storage solution developed at CERN.
ownCloud is an open-source enterprise for file sharing and syncing. oCIS (ownCloud infinite scale) is the rewrite of the ownCloud core with a high-performance microservices-based architecture. It has a Vue.js UI, Reva storage engine, and a Go backend. Phoenix (ownCloud/web) is the user interface of oCIS. The core components of CERNBox are based on ownCloud.
Currently, SWAN and EOS are tightly coupled through and with CERNBox. CERNBox will be migrated to oCIS soon. The aim of this project is to adapt the SWAN/CERNBox integration for a seamless transition to the new platform. At the end of this project, oCIS will be extended with functionalities to preview Jupyter notebooks in Phoenix (oCIS web client) and open them in SWAN for editing.
The project aims at extend the functionality of the current DBpedia chatbot by integrating the ecosystem of the Qanary framework including its plug-and-play components and plans to move to Google DialogFlow to use state-of-art technology.
The Fortran offers all the ingredients needed for building modules of various data types such as linked-list, maps, binary tree, etc.
This project aims to enhance the already existing and continuously improving Fortran-lang, i.e. stdlib, by implementing a linked list module in it. We wish to provide a module that can be used “off the shelf” by any Fortran user. The project mainly focuses on implementing the most efficient linked list and not just a simple linked list.
This project would involve adapting pathology annotation tools to prefer following edges in the base image when close and also add other smart techniques that will make it look perfect. With the current technology, it is possible to aid the process of annotation with computers. This tool will help the user to draw almost 100% accurate drawing/ annotation free-hand with the help of CV (namely, Canny Edge Detection and other algorithms). This feature is a bit similar to the magnetic lasso option in Photoshop.
Developers generally use standard optimization pipelines like -O2 and -O3 to optimize their code. Manually crafted heuristics are used to determine which optimization passes to select and how to order the execution of those passes. However, this process is not tailored for a particular application, or kind of application, as it is designed to perform “reasonably well” for any input.
We want to improve the existing heuristics or replace the heuristics with machine learning-based models so that the LLVM compiler can provide a superior order of the passes customized per application.
This project aims at building a chatbot that can query the DBpedia based on the (DBQNA) dataset, Using Natural language as well as Query language so that the DBpedia content accessibility can be increased and we can also enable community evaluation and feedback on DBpedia NSpM model.
This project aims to make the APIs more reliable, faster, operational and easy to maintain, this will be made by firstly, addressing all the aspects of the current codebase that need to be improved, introducing MongoDB to store the icons with all related metadata, adding caching layer using Redis, adding more features like generating SVG code-snippets, base64 encoded images, tags recommendation, filtering/searching, adding unit tests to ensure that the APIs are working as expected, and lastly a docker image will be made to have a solid deployment solution.
Designing user-freindly android apps for the users. Implement features to enhance user experience and work on optimization of the apps along with implementation of synchronization, HAPI Android Client. Also, cover the code with well wrtten tests.
Integration is a fundamental problem in mathematics, physics and computer science with many applications that span the whole spectrum of sciences and engineering. Monte Carlo Integration can be used to compute multi-dimensional definite numerical integrals using various sampling techniques using random numbers. It is used for various research and development purposes and it will help in extending VolEsti library’s functionality of multidimensional integrals.
TidalCycles is an Embedded Domain Specific Language for pattern, in use by 10,000s of musicians worldwide. However it has had little work done on the user interface side; text editor plugins exist for vscode, atom, vim and emacs, but they are all simple wrappers around the ghci REPL. As a result Tidal is difficult to install, with many dependencies (ghc, cabal,libraries, build tools, and the supercollider digital signal processing system and its plugins) which developers may be comfortable with installing, but end-user ‘live coders’ are often turned away by. My idea is to develop the proof-of-concept for a Tidal API and editor plugin that allows new interactions with Tidal, and opens it up to a broader userbase.
CircuitVerse's Interactive Book is a very helpful learning resource for everyone and expanding it to CircuitVerse's Mobile App will make it a real Mobile friendly learning platform for the community. Interactive Book Integration for Mobile App attempts to connect the ecosystem of CircuitVerse to all the platforms like iOS and Android.
The idea of the project is to extend the coverage of tests in the BrainBox project and also implement Continuous Integration and Continuous Deployment using CircleCI. Currently there are unit, integration and e2e tests written for the BrainBox project but the coverage is not extensive and only amounts up to 16% of the code. Hence the project proposes to extend the coverage of unit and end to end tests, while integrating them in the continuous integration of the platform and implement continuous deployment using CircleCI.
This project deal with implementing an unsteady potential-flow method namely the 3D unsteady vortex-lattice method for the aeroelastic analysis of the high-altitude subsonic aircrafts. Flexible multi-body simulation is carried out for the flight dynamics and the resultant loads from the aeroelastic analysis of the aerodynamic surface is used in the aforementioned dynamic analysis. Owing to differences in the mesh structures of the aerodynamic and the structural meshes of the MBDyn beams and interpolation method (namely Radial Basis function Interpolation) is used for coupling the two modules together and this coupled system is then solved using nonlinear time-marching schemes or are linearized and solved with highly efficient monolithic state-space schemes.
Sugar Labs has more than 250 activities GitHub and elsewhere which have scope for improvement. Since the support for Python2 was withdrawn from Python Foundation, porting the activities to Python3 and GTK+ 3 is very crucial. My work on this project includes,
My project will focus on 3 main tasks: (1) simplifying the launch of GRASS GIS sessions in Jupyter Notebooks, (2) creating a more intuitive way to display GRASS maps in Jupyter Notebooks and (3) introducing an interactive map display function for GRASS in Jupyter Notebooks using Folium.
Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations, which has become a de-facto Python plotting library. It allows user text to be rendered on the canvas, includes extensive support for mathematical expressions, raster and vector outputs, arbitrary rotations, and supports Unicode. Much of the inspiration behind its font manager is inspired from W3C compliant algorithms, allowing users to interact with font properties like font-size, font-weight, font-family, etc.
However, the current way Matplotlib handles fonts and general text layout is not ideal, which is what this proposal aims to tackle.
It is divided into three subgoals, such that by the end of the project completion, TeX exporting mechanisms would use the same structural layout for most backends, and every exported PS/PDF would contain embedded glyphs which are subsetted from the whole font. This would be done with an implementation of a redesigned text-first font interface, essentially enabling a font-fallback mechanism, such that all font-family members will be parsed before rendering a “tofu”.
The goal of this project is to make matrixStats functions handle names in the same manner as the base R functions. The methods of handling names should not create an overhead that could have a significant negative impact on performance.
Analysis and classification of race conditions on the linux kernel and marking them as false-positives/bugs, using LDV tools like Klever. Further reporting of bugs & sending possible patches for said bugs in kernel modules to maintainers
This project aims to extend AdvancedHMC.jl so that its implementation of static and dynamic Hamiltonian Monte Carlo (HMC) can be executed efficiently on the GPU. Additionally, a set of benchmarks will be created in order to uncover performance bottlenecks compared to Tensorflow Probability and NumPyro. Because AdvancedHMC.jl is one of the major inference algorithms in Turing this project will be a crucial step in bringing the power of GPUs to Turing. With the help of GPUs AdvancedHMC.jl will be able to scale to more complex models and larger datasets, making Bayesian inference feasible for a wider class of problems.
Storage is one of the main limiting factors to the recording of information from proton-proton collision events at the Large Hadron Collider (LHC), at CERN in Geneva. Hence, the ATLAS experiment at the LHC uses a trigger system, which selects and transfers interesting events to the data storage system. However, if those events are buried in large backgrounds and difficult to identify as a signal by the trigger system, they will also be discarded together with the background. To alleviate this problem, various compression algorithms are proposed to reduce the size of the data that is recorded. One of those algorithms is an autoencoder (AE) network that tries to implement an approximation to the identity, f(x) = x. Its goal is to create a lower-dimensional representation of the input data in a latent space. Then using this latent representation the model can reconstruct its input. Moreover, two advanced families of AEs are proposed, the Variational and the Adversarial AE. Next, various combinations of different compression algorithms are tested to compress and construct accurate representations of the input data. Finally, the studied AEs are implemented for anomaly detection.
Sequential Monte Carlo (SMC) methods are a general class of Monte Carlo procedures for sampling from sequences of probability distributions. The basic examples of these algorithms, termed particle filters, are frequently used in a variety of fields including signal processing, economics, and systems biology.
Recent developments, one example being Particle MCMC and Particle Gibbs methods, have gained considerable popularity. However, they require additional algorithmic extensions and are particularly computationally expensive. Hence, software support for these procedures is currently in high demand.
This project aims at providing straightforward implementation of modern SMC/Particle MCMC by extending the underlying template class library of RcppSMC which is currently not supporting these methods.
Benefits for the R community are expected, firstly, as SMC practitioners, who already use R, can reduce execution time as well as the time necessary for implementation in their everyday work. SMC developers, currently not using R as their first programming language of choice, hopefully see the benefits of the package, and thus might consider using R more often in this domain in the future.
Data visualization is a key aspect to understand complex models. In biology they work with complex structures composed of atoms, a common structure may have between 1k and 1000k (e.g. 6VSB “2019-nCoV glycoprotein” have 22854 atoms). Because of this amount of information, biologist work with different style representations (i.e. backbones, cartons…), labeling and painting to distinct between structures and understand more easily the molecular component.
Our understanding of Turbulence is still not very clear, studying fluid transitions to turbulence still poses challenging problems. The Navier-Stokes equations describe fluids in general and are based on Newtonian Mechanics. However, solving them for the general cases and understanding the solution behavior numerically and physically is quite complex. Obtaining numerical solutions for turbulent flow is quite difficult. Solving turbulent flows using laminar solvers doesn’t give steady solutions. We find the solutions using spectral simulations of the Navier-Stokes equations and apply dimensionality reduction techniques including but not limited to Autoencoders to study turbulence. Here, we aim at developing a statistical theory to well explain the transition of fluid to turbulence. The discussion and work will be limited to Newtonian and Incompressible fluids.
Post Exploitation APIs are the part of Metasploit-Framework with which the framework interacts after getting the shell from the target system. With this project I want to add the following enhancements
Currently if a filesystem API is present for meterpreter and not for shell sessions, the module writer has to drop the idea to use that API as it won’t be compatible with shell sessions. APIs which are missing for shell sessions can be added to create a layer of abstraction in order to make the modules use File System API irrespective of the shell type.
Operating Systems support many different languages. If the session is from an OS of different language, there can be some issues where the module might break because of wrong input output strings sent in the process of post exploitation as different languages might have different names for the same thing. This can be improved by adding the support for localization in which the strings can be modified based on the language of the remote system and also some processes can be modified to become independent of locale.
The project is based on creating an EHR system using the webcomponents implementing FHIR resources.
An EHR is a digital real-time, patient-centered record that makes information available instantly and securely to authorized users. This involves a lot of data and information transfer requiring a standard data model for improving interoperability which is given by FHIR (Fast Healthcare Interoperability Resources) Specification.
In the previous versions of GSoC this project was primarily based on creating web components for the FHIR resources with a goal to simplify the making of an EHR. For this year primary focus will be on the implementation of an EHR system utilising the FHIR components that will be created to be used together along with the components that are already present.
Implement two humanoid environments for the deepbots framework, using KONDO's KHR-3HV and Nao as agents. Work on zero-shot learning and extending the current API allowing other users to create new environments easily.
Boost.Real aims to provide a data-type that can represent all types of computable real numbers and provides the flexibility of performing arbitrary precision arithmetic. I propose to optimize the space and time by conversion of expression tree to DAG and by various arithmetic optimizations in operation. I propose to optimize space and time in addition and multiplication operations by utilizing one bit of wasted memory by making adjustments to Karatsuba multiplication and other helper functions. I propose to improve the Champernowne Irrational number and pi's digit computation and add e and golden ratio to irrationals as well. I propose to add more mathematical functions like inverse trigonometric, hyperbolic, cube root functions. After this, Boost.Real may be ready for peer review.
Pg-eu system is an infrastructure developed and maintained by Postgres for managing non-profit organizations along with an extensive conference management system. It contains a set of features such as invoices, administration of conferences, memberships, and elections, along with social media integration. Some improvements could be made to the system, which is being proposed, such as adding HTML emails and adding a generalized form-building capability.
Aims to implement an IIO driver for Analog Devices, Inc.’s (ADI) AD4695 16-Channel, 16-bit 500 kSPS SAR ADC, merge it upstream to the kernel tree and exhibit a working example on Raspberry Pi 3B+.
This a draft of my proposal to Bench-Routes organisation for Google Summer Of Code 2021. I have described in detail the approaches and implementation for ideas I am proposing to work on in this summer. The first idea, “Implement alerting based on the conditions/thresholds in Bench-routes”, is the core part of Bench-Routes. Alerting comes with hand monitoring as one cannot be present all the time. Hence Bench-Route will do the work and alert in case of abnormality in any metric. Alertmanager has an excellent scope for future development as handling alerts is a task in itself. Secondly, “Collector integration with dashboard” will increase the user’s ability to customize data monitoring in Bench-Routes according to their needs. This enables the user to extract the full potential of the Bench-Routes. The third idea, “Design of Scheduler for scheduling jobs and go-routines,” is crucial as controlling and scheduling the go-routines will enable Bench-Routes to launch and terminate go-routines in a proper way that ensures efficient memory utilization.
The Haskell Language Server is a popular, comprehensive Haskell IDE, however, it is yet to implement a core feature: symbol renaming. With the recent addition of HieDB (a database for references in Haskell code), there is sufficient infrastructure to implement this feature.
Having an accessible renaming feature could encourage improving names, leading to clearer naming across the Haskell community. Renaming is an especially useful feature in Haskell since short names are common, meaning they are often reused and difficult to disambiguate when renaming manually.
- support renaming of types and type constructors
- support renaming of qualified imports
NetBSD provides support for the ZFS system. However, it still misses the functionality to have your system root on ZFS, previously this was done manually by the user but with completion of the project this can be automated for the user. For that, we need to teach our bootloader about ZFS,xi. This project is to get the bootloader code ("libsa") to read ZFS file systems, thus enabling mounting ZFS as a root filesystem.
As everyone knows, TensorFlow is the best open source platform for Deep Learning. Instead of focusing on basics like alternatives which lag behind TensorFlow on visualization capabilities, documentation and not only datasets but also models, TensorFlow engineers develop the next-generation technologies. It is acceptable to say that TensorFlow shapes today’s technology. Therefore, I am eager to work on projects offered by TensorFlow in order to enrich mine in open-source software development by learning from the best and to apply my knowledge into TensorFlow which is the last word in machine learning libraries.
A proposal for the inclusion of OAuth 2.0 and OpenID Connect support in factotum. The main issue is that the structure of the OAuth landing page is not standardized. Therefore, one has to write a scraper or install a browser for the factotum module to work properly. Implementation plans for OAuth 2.0 and OIDC are then described, including a simple implementation of OIDC using the OAuth 2.0 Form Post Response Mode.
Nominatim is a software used to process geocoding requests on OpenStreetMap data. The software uses its own database schema which differs from the one used by the main OSM database. As a result, Nominatim processes OSM data in a way that allows to discover a lot of inconsistencies. The idea of the project is to build a Quality Assurance tool which will analyze the Nominatim database and extract the data errors to multiple formatted JSON files. The errors will be extracted based on a set of rules defined inside the tool. At first, the exported JSON files would be used to present all the errors data to OSM mappers through an Osmoscope instance. Thus, this tool will help OSM mappers to correct wrong data by taking advantage of the Nominatim internal data structure. The tool should be designed in a way that allows to add new rules easily. In the future, it should also be possible to extract the reports in some other formats in a flexible way. The process would be run once per day against the Nominatim database, stopping regular updates during its execution, so it is crucial that it is optimized to run fast.
708 is the standard for digital TV in the US and a few other countries. CCExtractor has an implementation of 708 decoder in C. This project aims to rewrite the 708 decoder in rust.
This project aims to provide Ceph users with the ability to report issues directly from the Ceph-Dashboard UI and attach all the available information to the report.
The project focuses on creating test harnesses for the fuzzer to exercise various Xen hypercalls through the Xen Test Framework (XTF)
The hyperSpec package allows R users to analyze spectroscopic data. Operations include importing spectroscopic data, plotting, pre-processing, and common chemometric analyses. The current infrastructure of the package is difficult to maintain due to a dependencies on other R packages and a large amount of test data. Although there has been good progress during GSOC 2020 to modularize hyperSpec, there is still much work to do. This project will further refactor hyperSpec to reach the goal of a robust and readily-maintained ecosystem of related packages.
This Project aims to develop unit and integration tests for the Niffler modules and implement automated testing using Continuous Integration. The Testing framework will include both manual testing as well as automated testing to reduce overall manual effort in testing. The project will introduce checks to confirm that the commits to the codebase do not break the functionality of Niffler, before each major production release. These tests will significantly reduce the potential for bugs in the codebase, allowing the deployment of newer versions seamlessly.
PyQuotient are Python bindings to libQuotient, a Qt-based library to make client applications for Matrix and. The proposal includes also a basic Matrix client application in Python using PyQuotient.
As of April 2021, the iOS KDE Connect application possesses several issues:
Outdated UI design and features such as optimizing for newer aspect ratios, icons, fonts, and accessibility, etc.
The app is lacking many core functionalities of KDE Connect that other currently available versions have. Since Apple has implemented many of those features into iOS since 2014, the app would now be able to use them to offer the missing functionalities.
The backend portion of the app that governs LAN network communications is currently functioning inconsistently and only under a very specific series of actions.
The goal of this proposal is to address the problems listed above with an "analysis and rewrite" process of much of the app’s current code base with the newest Apple development language and UI framework, Swift and SwiftUI. Aside from solving the immediate problems with the current app, rewriting the foundation in Swift and SwiftUI would give the codebase a strong footing to expand and adapt to future contributions. SwiftUI’s cross-platform deployment capabilities also give the possibilities for forks of the codebase for other Apple platforms such as macOS and watchOS.
An automated pipeline for running old models from scientific papers with new versions of the TARDIS code in order to check that scientific inferences are still valid.
The project deals with converting cp-demangle into bespoke heap-allocated data stack for the recursive state, and implement a non recursive approach to demangle cpp function names.
Currently cups calls a sequence of filters in order to convert the input file format to the desired format. This makes CUPS call a lot of external executables which is resource consuming. Now that most of the filters are converted to filter functions, it would make more sense if we call the functions one by one in appropriate order instead of calling external executables. The aim of this project is to create a single universal filter which would check what the input and output formats are, figure out the sequence of filters required and call those functions to get the desired output.
PyMC is currently developing the new PyMC3 4.x version. Core changes involve the use of the new RandomVariable class to simplify/speed up random sampling and emphasis on using dynamic shapes during pre-sampling analysis. The main aim of this project is to assist the conversion of the remaining PyMC3 codebase.
Sample code and documentation explaining the use of cross-platform compatible implementation of OpenCV's Universal Intrinsic and parallelfor
This project focuses on refactoring code to kotlin and implementation of MVVM (Model-view-viewModel) architecture for some of the UI components of the application. Implementing some of the recommended Android architectural components along with kotlin refactoring to enhance robustness of existing codebase and make it more testable and maintainable for future development.
This project is aimed at helping list owners to config their list using templates, which can also be exported to a JSON file. This will enable the list administrators to transform one list’s configuration to another server, and it will also make creating a new list based on the existing configuration template possible. The configuration templates will form into a table in the Import/Export section of list_settings, which will make it possible to be managed (edit and delete). Meanwhile, all the templates can be applied to existing lists to overwrite all the settings specified by the configuration template at one go.
CCSDS File Delivery Protocol (CFDP) is a file transfer protocol for use in space, e.g., between Earth and spacecraft in Earth orbit or between Earth and spacecraft on interplanetary missions. The CCSDS File Delivery Protocol (CFDP) has been implemented in Python by LibreCube. This project aims to make the existing setup OS independent and make it compatible with micropython and extend its utilities as a ready-to-use space software. It will be demonstrated using the pyboard as the server and using UDP transport over WiFi. This project will also include extending the capabilities of the current system and testing the system exhaustively. The CFDP GUI application made by LibreCube shall be used for this and extended/modified as needed.
RTEMS already supports the Raspberry Pi1 development board, and has a fair bit of support for the Raspberry Pi2. The Raspberry Pi Zero/ Zero W is a low cost board that can run RTEMS and is based on the same SoC as the Pi1, whereas the Raspberry Pi 3 is an upgrade on the Pi2 and is more widely used. My project aims to add RTEMS support for the Raspberry Pi Zero, Pi Zero W and the Pi 3.
Implementing an in-proxy authorization cache for envoy proxy using web assembly and proxy-WASM rust SDK. The cache will be in synchronization with 3scale Service Management API by periodically flushing the local cache snapshot and updating the local cache with a new cache snapshot provided by 3scale Service Management API. When a HTTP request is received by the proxy, it will do a look up in the cache to check whether a cache record exist for that particular request. If a record exist, then perform authorization logic based on that request (cache hit) . If a cache record does not exist(cache miss), do a HTTP call to 3scale Service Management API to fetch relevant authorization data, add the records to the local cache for any subsequent requests and perform authorization based on the received data. For the project, a request intercepting HTTP filter and a singleton service that runs independently from request life cycle will be implemented using proxy-wasm-rust-sdk and will compile them as web assembly modules to extend envoy proxy with the HTTP filter and singleton. Web assembly modules allow us to extend envoy without building the envoy static binary using bazel build system.
This project is based on an existing Cubesat AOCS Simulation code. Currently the set of sensors for navigation and actuators for control is limited. It is planned to include multiple options to customize the cubesat and evaluate the control and navigation functions depending on the selected hardware.
In this project, a solver for Riccati ODEs will be added to the ODE module of SymPy. The solver finds all rational solutions of the equation. A rational riccati solver is very important for solvers that solve second order differential equations and a general solver for any first order algebraic ODE. An extensive database of ODEs from famous books like Kamke, Murphy will also be prepared. This database will then be used to test the new solver and the existing solvers.
To create an open, community-powered Book Genome Project which enables deeper, faster and more holistic understanding of a book's unique characteristics.
Spir-fuzz is a C++-based tool that automatically finds bugs in Vulkan drivers. It works by transform the original shader into a new one that is semantically the same. Differences in the output of the new shader and the original one can be caused by bugs in the driver. Thus, our task involves expanding the set of transformations by building sets of transformation classes and writing their corresponding tests and fuzzer passes.
Our main task involves the WebGPU Shading Language, a new shading language featured by WebGPU. Since web browsers will have WebGPU, a secure implementation is crucial. To achieve a high test coverage, we use coverage-guided fuzzing. It uses program instrumentation to trace the code coverage reached by each input fed to a fuzz target. The information is then used to make informed decisions that maximize coverage, and thus increase the effectiveness of finding software bugs and security vulnerabilities. This project involves automatic fuzzing using LibFuzzer. Since LibFuzzer-based custom mutators mutate test cases in a domain-specific way, effective designing and implementing Tint-specific custom mutators are essential for this project to succeed.
I would like to create two completely new tutorials for the Turing package, covering biologically motivated applications, in particular factor analysis for uncovering hidden biological structure.
The aim of the project is to build a Text User Interface(TUI) for issuing and receiving QEMU Monitor Protocol (QMP) commands from a running QEMU instance.
MapAction’s mission is to provide people dealing with humanitarian emergencies with supportive maps as quickly as possible. Currently most of such maps are produced manually by experts. The problem is this process might take hours while each spent minute costs people’s lives. Thus, automatization of map producing is mandatory. That’s why MapChef was created. MapChef works with recipes to create maps. In the wild, however, data is not represented in MapChef’s desired format. It must be prepared. And since manual data acquisition and preprocessing is time-consuming, creating a pipeline for automatization of this work is highly desired. Recently, a series of data pipelines has been implemented.
At the moment MapAction’s data pipeline framework can deal with two types of data: country boundaries from HDX and roads from OSM. This project aims to extend this pipeline to other types of data. Achieving this will increase the quality of the automatically generated maps. As a result, MapAction will be able to provide people responding to crisis with significantly more vital information immediately after an emergency.
This proposal details how I will be dealing with the project named Productionizing bddashboard . The main aim of my project is to create a testing framework of the Shiny application from bdverse that aids in visualizing biodiversity data, including but not limited to unit testing the UI and server, load testing, random testing, stress testing etc. For developing this framework I'll be working extensively with the testthat, shinytest, pupeteer, crrry, gremlins and shinyloadtest packages.Apart from testing, I'll also be responsible for finding the CI/CD pipeline solutions for our project after comparing and reviewing the available options out there. My final task would be to get our project (Shiny project) accepted into CRAN and eventually get a new and updated version of bdverse pushed out for public use.
Deploying an email service requires patience and technical expertise, as it involves orchestrating a myraid of heterogeneous software components. The benefits of self-hosted email is greater privacy for end-users. In the past, Debian contributors had unsuccessful attempts to compile a unified package that would make such deployments easier. My proposal for GSoC ’21 outlines a 9-week plan for packaging an email server to be run on Debian-powered SBCs. It is divided into 3 release cycles and 2 “extra credit” tasks. If successfully completed, the end product will provide interoperability, spam detection, transport security through encryption and traffic filtering through isolation.
Make TVB Visualization Tools compatible with Jupyter Notebooks and Google Colaboratory
One of the best ways to learn Spinnaker is to use Spinnaker. This project is focused on generating (and destroying) temporary sandbox environments for new users to play around with, hosted by spinnaker.io.
The aim of this proposal is to build a pure Rust serverless implementation of htsget - a client/server protocol for reliably and securely sending genomic data over a network - which will be integrated with AWS lambdas.
Image Quality sorter is a tool of digiKam. It helps users to label image bt accepted or pending or rejected. However, the current implementation does not have a good performance. My proposal provides my perspective to improve this functionality.
All electromagnetic phenomena are governed by the Maxwell's equations, which describing how electric and magnetic fields are distributed due to charges and currents, and how they are changing in time. gprMax is open source software that simulates electromagnetic wave propagation by using Yee's algorithm to solve (3+1)D Maxwell’s equations with Finite-Difference Time-Domain (FDTD) method. The behavior of the electromagnetic wave is closely dependent on the material in which it propagates. Some dispersive media have quite complex electromagnetic properties depending on the wavelength. This, for example, means that for different frequencies the wave can propagate with a different speed in different materials. This significantly affects the solver’s output. The main goal of the project is to enhance series of scripts, which modelled electromagnetic properties of the variety range of materials. Initial series of scripts have been prepared, however, their technical improvement and coupling with main software gprMax is required.
Development of an AI-based Android Application for distinguishing COVID-19 and Pneumonia using Computed Tomography Images.The project aims at development of an Android application capable of efficiently generating a report based on AI capabilities of the well trained neural network, using the Computed Tomography (CT) Images of patients as a part of the project. The report will show the AI predicted results for distinguishing covid-19 and non-Covid-19 disease using the CT Images. These results will also contain saliency maps and segmented regions to better outline and detect the affected regions from CT Images. The application would be equipped with computer vision algorithms such as contrast stretching, adaptive and global thresholding, Image enhancement and many state of the art methods to carefully present every detail from the CT image. The backend of the application would be optimal for performance of trained Deep Learning Models and computer Vision Algorithms.
The aim of this project is to build an application for Liquid Galaxy that allows us to observe satellite data next to the representation of the satellite.
The data visualized will be obtained mainly from the SatNOGS network and will be displayed next to the satellite while it moves around the globe.
The user will be able to visualize this data and have an approach of open-source satellite data and it would help the mainstream public to understand the kind of information that can be collected by a satellite.
The core of the project will be coded using Python.
I plan on developing the Bhojpur-Hindi language pair in both directions i.e. bho-hin and hin-bho. This will involve building a monolingual dictionary for bho and the bho-hin bilingual dictionary. The next step would be morphological disambiguation and writing suitable transfer rules to bring this pair to a releasable state.
The continuum mechanics of Sympy is in its early stage of development. During this summer, I plan on adding the following features:
Selecting a good product for consumption is hard due to bad products in the market. So an application that can trace a product and its raw materials are the best options to have when shopping. S-ChainX is such an application. But it should integrate new features to make consumer's life easier. So Quick product search, Customer feedback, Court order links, Ingredients, and their effect on the human body are key facts that consumers need to aware of when buying a product. So in this project, I will try to add these enhancements to S-ChainX application. Also, I'm hoping to add unit tests and integrate the sonarQube to improve and maintain the quality of the code.
KMyMoney is a cross-platform personal finance tracking app. It uses C++, Qt as its core and the UI is done using QtWidgets. KMyMoney 4.8 is equipped with debug functions and extended by an online update of the quote sources. This was added to Alkimia 8.0 The main goal of the project is to add that as a feature to KMyMoney version 5. I have planned to add this support to version 5 of KMyMoney, as a replacement for existing functionality in KMyMoney (as was done with version 4.8). After extending the support a user will be able to:
An Awesome Tutorial Game ( playable on both phones as well as on smart TV when cast ) in Catrobat Visual Programming Language. The game is inspired by a hugely popular 2D game “Hollow Knight”. The main character of the game is Batro who is the king of the Batona kingdom. At each level, king Batro fights with one of the evil monsters and crosses the hurdles and In the last level, the king fights with Giant Monster Martian and frees his Kingdom from the evil Monsters. The player follows Batro in his journey. The game story is easily depicted through cinematic cutscenes for better insight. The game is very easy to play and get into, with on-screen controls, and a fairly simple UI. The game is playable on both phones and on a smart TV without looking at the phone's screen while using the phone as a gamepad. This game shows how the ‘Pocket Code’ app can be used to develop high-quality video games if used efficiently and effectively.
The proposed project is concerned with the implementation Automatic Generation of Qualia Relations between Lexical Units in FrameNet. The main point of the project is to enrich the data in the existing FrameNet-BR database with some of the information available in BabelNet, more specifically the relations between various word senses.
The project is going to be composed of two individual components encompassing two independent processes: an extraction tool and an annotation tool.
The extraction tool is meant to utilize the available information in FrameNet-BR and BabelNet and generate a set of hypotheses, i.e. possible qualia relations between lexical units.
The annotation tool is meant to provide a visual interface to a human annotator, so that they would be able to evaluate the quality of hypotheses generated by the extraction tool. Hypotheses of acceptable quality are expected to be added to the FrameNet-BR database.
My project is divided into three parts:
For the first two parts, my work will consist in studying scientific publications with the aim of recovering the mathematical formulas of the models to port them in python and for the third part my work consists in refactoring the python code in "object".
The solution will act as a BROKER that manages subscriptions for update notifications for each deployment subscribed by system administrators
System Diagram: https://drive.google.com/file/d/1risThs_kBWBYJjvepytUaDIQDxpL2w3T/view?usp=sharing
PyBaMM offers a way to compare new models by implementing models as expression trees that can be specified independently of the user's preference. Apart from simple equations, there is no way to print the equations in a human-readable form. This project aims to use LaTeX to render the tree into a human-readable format by generating a pdf of the model equations so that the user can visualize the equations easily.
Purpose of this project is to create a suite of GitHub Actions workflows for scheduled algorithm deployment on datastreams from Ocean Observatories Initiative and Orcasound hydrophones.
This project will seek to identify dimensionality-reduction methods that achieve a reduction in the number of features while maintaining predictive performance of the relevant models. This will be done in the context of astrophysical data, however, the problem of many features is common in many areas, including genomics, economics and imaging.
This project aims to develop a feature for Real Time Collaboration on the caMicroscope Slide Viewer which would give users the ability to work together in real time.
Current version of newman ships with a newman run command that allows users to effortlessly run and test postman collections from the command-line. We are in the process of writing a new command - newman request - that will enable users to run single requests from command-line. Replacing curl with newman request in a curl command should run and send the request using Newman. Newman request will be a drop-in replacement of curl which will allow users to show additional details like response time, size of data received, first byte time , DNS lookup time, etc. in CLI. Users will be able to use existing features of Newman like showing output with reporters of their choice that provide information about single request in a format that is easy to both disseminate and assimilate. Existing reporters like HTML, JSON, progress, etc. will be supported. Additionally, if a user is logged in, the request will show up in the Postman app’s History sidebar. To achieve these objectives, we are using curl-to-postmanv2 plugin to convert the command to postman collection with a single item. The created collection is then run using postman-runtime.
I will complete remaining work on TypeScript migration from last summer.
To guide behaviour, it has been proposed that neurons eventually learn to predict future states of sensory inputs. The project mentors have worked in this direction to get metrics on these predictions about how accurate those predictions are if the neuron used synaptic learning rules. The main contribution of this project would be to publish highly optimised library codes that can serve as evaluation benchmarks for predictive accuracy. We also believe that neurons can generate efficient encodings on these predictions. Through this project, estimates of the predictive information would also be obtained by neural models.
TARDIS is an open-source code for rapid spectral modelling of supernovae using Monte Carlo methods. To run the simulation model, TARDIS requires some information such as velocity of shell structure, density, abundances, etc. These input parameters determine the composition of supernovae that the user wishes to explore.
At present, the model composition is initialized by a configuration YAML file or a CSVY format file and it is impractical to adjust the composition without the two files. Therefore, users have to edit text files manually in order to change the model composition, which tends to be inefficient and inconvenient for them. In this case, a custom abundance widget is proposed to provide a more convenient way in supernovae exploration. The project aims on abundance customization and allows the user to develop custom model compositions graphically, which can then also be output to a file.
Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.
Project Ideas are as follows:
My project will mainly focus on extensive Graphical User Interface (GUI) refactoring necessary to prepare GRASS GIS for Single-Window GUI. As the result, I will introduce a very simple Single-Window layout and importantly a good programming base allowing further convenient extension and improvement with additional functions.
Knative is an open-source community project that extends Kubernetes with modules for deploying, operating, and maintaining serverless, cloud-native applications. The serverless cloud computing model has the potential to improve developer efficiency while decreasing operating costs.
The project idea is to develop Charmil, an open-source Golang-based platform that will serve as a package manager which assists in the discovery and installation of plugins from a community-curated plugin index. These plugins can then be embedded into any host CLI with additional features such as new version detection and smooth upgrades.
Through Charmil, each CLI will be able to install other CLIs as extensions, thereby organizing them in a hierarchy. This functionality of Charmil will later be used to add new features on top of the Knative CLI.
Currently, Qubes OS lacks a centralized an easy way to forward ports to virtual machines. Although it is possible to forward ports by issuing iptables commands on both the NetworkVM and the FirewallVM, or by using the ConnectTCP service, it is a limited and error prone manual process. Furthermore, the lack of a GUI that shows the manual rules fives the user a lack of oversight on the firewall.
The goal of the project is to mplement a GUI for automatic and persistent, eventually with a predefined timespan (ie: until reboot), port forwarding. The idea is to split horizontally the "Firewall Rules" tab in the "Qubes Settings" window and add another area below it.
Additionally, discuss and verify the possibility to implement a secure NAT traversal system and GUI. A basic proposal could be a checkbox to enable NAT traversal requests. When the checkbox is selected, the FirwallVM will redirect NAT traversal requests to a local python daemon or a dedicated VM that will negotiate the NAT traversal and configure the network accordingly. In this case, prompt the user in Dom0 about the NAT traversal request.
Of course the qvm-* set of tools must e able to achieve the same tasks via CLI.
This project aims to extend the existing tensor type by providing support for subtensors, i.e. views of tensor along with the auxiliary types. The projects' scope is to improve the existing subtensor implementation while simplifying the overall design and usage.
Rivet is a tool used by particle physicists to test and develop Monte Carlo event generators, i.e., simulation of particle accelerator collisions. Simulations are crucial for particle physics research, since they can be used to compare theoretical predictions with experimental measurements to discover new physics.
Visualizing the output is a fundamental part of Rivet, as a good visualization makes it intuitive and easy to understand the results. Currently, plots are created by generating and compiling LaTeX commands. While this method does create high-quality plots, it can be slow, have memory issues, be sensitive to the deployment platform.
The goal of this project is to solve the above mentioned issues by replacing the LaTeX plotting backend with a new high-level API that can support multiple rendering backends. The API should make it easy to export high-quality plots, while still allowing full customization for advanced users. Matplotlib will become the first rendering backend that will be added to this API, and options for exporting figures into interactive plots in the browser will also be investigated.
Development and implementation new kind of io_cache for optimization's purposes
Solar resource data is fundamental to designing and assessing solar energy systems, however, accessing such data is often a complex and time-consuming process, as each data provider has different file formats, methods of access, and naming conventions. The aim of this project is to extend pvlib python’s current iotools functionalities to include harmonized functions for allowing seamless access to all major open-source solar resource databases. This will strengthen the pvlib python library by making it a one-stop source for all types of open-source solar resource data and will be a huge benefit to solar energy researchers and scientists.
Photodentro is the official repository of K12 educational material for Greece. It contains more than 15,000 learning objects or applications which are implemented in HTML, Adobe Flash, Java or other technologies, and it's used by thousands of students and teachers. Unfortunately, it has the following limitations:
I propose the development of a new sch-webapps application that will address these four limitations, hugely benefiting K12 education and possibly many others.
With the completion of the experimental and regional phases, China's BeiDou Navigation Satellite System (BDS) is being speedily expanded to a global and multifunctional satellite navigation system. The proposal shows that some signal processing and information proceeding techniques based on BDS-3 B2a signal, which can be achieved at GNSS-SDR. and tell the plan, deliverables, communication and qualification about this project.
Extends the current functionalities to the next stage with the core objective of gaining the most prominent concepts in the image processing domain with the help of the OpenCV library. Also, provide fundamental image processing exercises via predefined operator streams/pipelines. Provide better usability and user experience with the provided operators and able to provide a fully functional image processing tool for the end-user.
This GSOC project aims to optimize Nemo execution by performing hierarchical aggregation and controlling its fidelity based on the distance of a geo-distributed data processing environment. The project consists of four main tasks: First, implement and check the correctness of the hierarchical aggregation. Second, evaluate the performance improvement in the point of throughput. Third, add the layer of fidelity control which varies on the different levels of hierarchy. And last, implement a learning-based model which automatically adjusts the hierarchy and fidelity level.
The goal of my project is to replace the current default database search backend in Wagtail, which is a dummy backend that comes enabled by default, with a functional one that works on SQLite, PostgreSQL, and MySQL.
My specific goals are:
Project Summary
Testing of software is important since it discovers defects/bugs before the delivery to the client, which guarantees the quality of the software. It makes the software more reliable and easy to use. Thoroughly tested software ensures reliable and high-performance software operation. Now to ease regression testing time and for better efficiency to validate complex scenarios automation is preffered.
The Major Goal
Currently mediawiki is using Webdriverio as a browser driver for our test automation framework which is at version 6 (exception: 2 are at V4). The goal of this project is to migrate them to version 7 (Latest) Which was released recently on Feb 9 , 2021. Also we need to perform cleanup and refactoring of the existing WebdriverIO code across all repositories. (Additional goals below).
Features in new updates
Stricter Protocol Compilance Test Coverage Reporting Dropped Node v10 support Improved google lighthouse Integration
The Additional Goals:
Enabling of video recording in all selenium test Sanitizing Page Object Imports across all repos. Extending the wdio.conf.js file so that the same file can be used/extended across all repositories.
Is to implement MobileNetV1 which will also include implementing depthwise separable convolutions and a resnet model builder that can be used to create resnet18, resnet34, resnet50, resnet101, and resnet152. This project would fall under the idea: Ready to use models in mlpack, the resnet builder and MobileNetV1 will fall under the models repository and depthwise separable convolutions will fall under the mlpack repository as a layer inside the artificial neural network codebase.
The Buddhist Digital Resource Center has a well-maintained database. The entities present on Wikidata often lack a label in Tibetan language. By adding a Tibetan label during the import we can dramatically improve the usability of both Google and Wikidata for Tibetan natives and community. The project will focus on various aspects of data engineering to provide the best solution to help the Tibetan community.
Wikidata has proved to be the most efficient open source of knowledge having structured data which is extracted directly by google and affects the google search result directly. Knowledge Graphs pull in data from a variety of sources such as Wikidata. This data is used to understand user search intent and to answer search queries. The project will focus on importing data of places and persons from BDRC database, as well as the addition of new data on existing Wikidata records from BDRC. All the shortcomings present in the database will be dealt with and improved.
Upon successful completion of this project: The Tibetan community members will be able to get better search results. The labels added will result in efficient use of Wikidata for the members of the community.
Story is a fun way to get children to engage in narration. We simply generate some images and the learner should try to tell a story that ties the images together into a comprehensive narrative. It will help children to engage themselves in learning new things. It will help to enhance the imagination and creativity of the children.
BuildingSMART organisation is currently working and about to publish new IDS (Information Delivery Specifications) which in simple terms is a machine-readable standard for building information modelling (BIM) requirements. Thanks to IDS, it is possible to automatically verify exchange requirements of BIM models delivered in IFC format.
In my project, I will first focus on the validation process using IfcOpenShell to make sure it fully supports the new XSD (XML schema definition) of IDS and create sample IDS files to test it against. Furthermore, I aim to enhance this feature with BIM Collaboration Format (BCF) output of such verification, which will be integrated into the BIMTester tool.
The last step would be to allow for easier creation of IDS files by non-coding users. The idea is to add the authoring functionality of BIMTester web UI. This is where the work overlaps with the project of another GSoC student.
The detection of risk situations during the navigation of mobile robots is an essential task for future applications. The goal is to create a software agent in Robocomp with the aim of improving vehicle driving, using deep learning and computer vision techniques.
The main idea is to use one or several RGB cameras placed in a vehicle for lane detection, pedestrian detection, vehicle detection, sign detection and more elements that affect driving. To perform this task, it is possible to work either with real datasets of cameras placed in vehicles or to use the Carla vehicle driving simulator.
This project aims to create a tool that allows anyone to become a market gardener, given some space. As a first step, a user will merely sign up and enter the amount of space that (s)he wants to use. The system will then trigger tasks the user has to do to farm on his space efficiently. Those tasks are triggered by simple rules and may depend on weather events, date, and later also other triggers. Thus, anyone can be a market gardener, and this tool will be beneficial and easy to use.
Intracranial electrophysiology is commonly recorded during and after invasive brain surgeries in epilepsy patients to determine where seizure activity starts. These recordings are also used to learn about normal brain function under various experimental conditions. The first step in analyzing intracranial electrophysiology recordings is determining the location of the electrode contacts in the coordinate frame of a subject’s T1-weighted magnetic resonance image (MRI). The subject must also have a computed tomography (CT) image taken during or after the implantation surgery. The pre-surgical MRI has better resolution of the brain anatomy than the CT, whereas the CT shows the positions of the electrode contacts. These two 3D images allow the location of the electrode contacts to be associated with anatomical brain structures. MNE-Python has existing tools for analyzing time series data recorded by intracranial electrode contacts but there is a gap in the functionality in being able to label the location of intracranial electrode contacts. The proposed project is to add a graphical user interface (GUI) that allows users to localize electrode contacts as an enhancement to MNE-Python.
There are a lot of tools that offer code recommendations to developers when programming a software project. Code critics are a highly used recommendation facility of the Pharo Smalltalk IDE. They aim to promote the use of good and standard coding for increased performance or a better use of object-oriented constructs.
Despite the great contribution it makes to programmers using Pharo, there are still issues that can be improved. These problems create difficulty for Pharo beginners; Pharo beginners believe their learning status induces the difficulty using code critics and results in a truly bad experience with the IDE, the language and even programming. We will perform several improvements to the code critics and introduce profiles to select which rules to run depending on the mistake made.
An asymptotic expression typically contains exact terms and O-terms, for example n3 + 2n2 + O(n). The basic framework for this asymptotic ring is already implemented. The main aim of this summer of code project is to extend its functionality up to the point where asymptotic expressions with explicit constants are fully supported. In his book, “Asymptotic Methods in Analysis” on page 5, deBruijn calls it an “L-term”, but we will call it “B-term”. B_{20}(3z) is a B-term, which stands for an expression which is bounded in absolute value by 3|z| for |z| ≥ 20. Sometimes, in research, it is important to know from which values of the variable on the asymptotic expression has enough precision to decide wether it is larger than a given bound. This cannot be achieved by O-terms (because the unknown implicit constant might be very large). For example, the average number of comparisons of classical quicksort is 2n log n + O(n). When comparing with recent variants, such as dual pivot quicksort with average number of comparisons 1.8n log n + O(n), it is interesting to know how large the O-terms are in order to know when dual-pivot quicksort will be more efficient than classical quicksort.
Problem: Many users use Joplin for research purposes, so it is natural for them to do citations all the time. Accordingly, adding a feature that supports citations and BibTeX will be of great benefit to Joplin.
Solution: The solution can be described as a plugin that can do the following:
.bib file).There are other requirements that must be met. For example, the UI should be as user-friendly as possible, automated and manual tests are to be carried out, every component of the codebase will have a documentation.
Implementation: The implementation relys heavily on Joplin's plugin API to do all sorts of things such as showing dialogs, accessing settings, and modifying content.
Often, it's useful for users to compare different results on an image. To facilitate this, caMicrocope supports viewing the same image with different results, such as heatmaps, segmentations, and annotations, in a coordinated fashion. Since adjacent tissue slice images are usually quite similar, it can be useful to have a similar coordination between different images. This project focuses on creating a tool to allow a user to do this. The two different tissue samples may be differently situated in their images, and may require a user to change scale, position, and rotation to sync up the two images.
Machine learning models are being used to assess loan and job applications, in bail, sentencing and parole decisions, and in an increasing number of impactful decisions. Unfortunately, due to both bias in the training data and training methods, machine learning models can unfairly discriminate against individuals or groups. While there are many statistical methods to alleviate unfairness, there’s a growing awareness that any account of fairness must take causality into account. This project aims to implement causality-based tools for checking and forcing fairness into the Julia ecosystem of machine learning tools. Specifically, we intend to extend the packages Fairness.jl and MLJ.jl to include methods that implement counterfactual fairness, a recent definition of fairness. We will do so building upon principles of causal graphical models and causal probabilistic programming, as implemented in languages such as Omega.jl and CausalInference.jl.
This project aims at adding some missing functionalities in Pharo DataFrame. Implementing the missing features and functionality of Pandas DataFrame in the Pharo DataFrame namely, Addition of the dtype object and Addition of the DataFrame slicing feature. Add examples of applying the DataFrame and its new features to real problems of Data Science by using samples and Datasets into the official Pharo documentation .
This project aims at improving Purr Data's documentation browser and leveraging it to an autocomplete feature for objects and messages:
The idea is to improve the user experience and increase the fluency of the day to day patching.
This project aims to add the feature of auto-organizing the position of nodes in graph edit, visual shader editor and visual script editor, while editing it. The methodology presented in this proposal is inspired by Sugiyama's methodology, which is very popular and commonly used in many software to automatically draw directed graphs. The methodology has been modified to fit the needs of the users, also keeping in mind the design architecture and implementation of the graph editing system in Godot. The end result would be ease of designing large graphs and having more lucidity when debugging, hence adding to the user experience.
Currently, PAPPL supports only raster printers and that too for very few specific input formats like JPEG and PNG. Adding the code in PAPPL for adding support for other file formats like PDF, GIF and SVG for uploading, and managing and removing already uploaded files. Adding the generalized code in PAPPL for uploading and managing custom PPD files as that in PostScript Printer Application, for all types of files that PAPPL supports including firmware files, for eg. by making use of callback function support to check the format of the file.
Enhance Project Repository includes:
Enhance Project Webapp includes:
White-list on web page for corporations that pledge for sustainability or donate for the cause; Win-win for DIAL, social corporations, and the less privileged community
The purpose of this task is to define an ontology for conversations and to create a Java library based on Apache Clerezza to store them. Signal (https://signal.org/docs/) is one of many messaging apps which is open source. This task recommends to integrate the library to be developed into Signal (https://github.com/signalapp) for testing.
Static analysis for unreachable functions
The ontologies dashboard was developed last year to show the statistics of the data in an interactive manner for helping community members to get a quick overview from different SPARQL endpoints and Databus collections. This year, the focus is more on user engagement for performing data analysis without leaving DBpedia’s Ecosystem. The project is about including more user-customized activities. This includes enabling user login and creating multiple dashboard instances by specifying the Databus collections. The users can write queries and get the results for visualizing the data, here itself. The system will allow users to publish their own dashboards of their linked data by plotting the graphs they like. With this, there are benefits like: User retention rate, and Flexibility for deriving insights.
The system design of this project uses the state-of-the-art approach for developing the user specific dashboards by querying the data on specified sources in a modularized manner. This could be the addition of new sub-system in existing DBpedia's Ecosystem.
The "hofa" package for factor selection and estimation based on higher order moments. The aim of my GSOC project is to turn this package into a go-to package for analyzing the difference between higher order moments and covariance based methods for factor selection and estimation. This requires adding a large number of methods, including test cases and improving the package structure.
Build a offline TFLite GPU inference latency estimator with ensemble of regression models
Scancode uses various different techniques to detect licenses based on various multiple sequence alignments ,automations etc. but the detection results are not always accurate enough as expected. The aim of this project is to improve license detection accuracy in general For example: detecting unknown licenses and study indirect references and as a whole gain more insight into the Scan Results.
Goals to be accomplished:
1)Main motive will be to improve license detection accuracy for the licenses that are declared as “Unknown” and optimize somehow the way they are handled currently.
2)Detailed review of the licenses which are marked as “Unknown License Reference”.
3)General Improvements for the licenses that are detected incorrectly .Having statistical analysis of all license detection scans (including minimum coverage , score etc.) and of existing license texts and rules.
This project aims at adding strict static type checks to oppia codebase and introducing protobuf for constants. In this project, static type checking will be done with the help of MyPy. Adding static type checks is useful in catching errors before runtime and helps developers in debugging the program. In this project, type annotation will also be added to a part of the codebase. Introducing protobuf messages for the constants will help in making the codebase more typed.
Genomic assays generate lists of genes or proteins statistically associated with a condition, such as being altered in disease. Genes need to be systematically linked to other layers of system organization to develop a hypothesis about the mechanism of action, and to drive downstream experiments. These layers include information about intracellular interacting molecules, the types of cells genes are expressed in, and what diseases are known to arise from altered function in genes. Finally, rational drug design is furthered by understanding drug-gene interactions. Gene lists are currently turned into exhaustive tables containing cross-references to various databases of annotation, without a systems-level framework to visualize the data. This GSoC project proposes to create a network-based hierarchical viewer to visualize gene annotation at various levels of systems organization, including gene-gene interactions, cell type, disease, and known drug targets.
PyMC3 is a probabilistic programming language that uses Bayesian statistics to specify models and estimate unknown quantities. PyMC3 has about seven time-series distributions, an important class of models in Probabilistic Programming. This project works on extending this class in a few ways: Firstly, the addition of a new model - namely Auto-Regressive Integrated Moving Average(ARIMA). Expansion of the existing distributions(and their respective documentation), including Time-Series analysis functions. Thirdly, state-space implementation of possibly a time-varying linear and Gaussian time series model, based on Aesara. Additionally, I believe that Programming can be an efficient way of understanding applied mathematics, motivating me to focus on more pedagogical or explanatory notebooks about Probabilistic Programming (Time-Series in this case). Explanatory Notebooks for ARIMA and state-space model usage, exploring their Econometric applications will be a small step towards fostering an interdisciplinary bond between academia and the open-source community, mutually benefiting both.
Object Detection is one of the most popular use cases of computer vision. Thus, a modular and easy to use package for training and inferencing would be very useful. I wish to contribute by implementing state of the art anchor-based detectors like EfficientDet and anchor-less detectors like CenterNet to the existing TensorFlow model garden. Along with implementing them, I would also like to explore the possibility of additional support for optimizing the models tensorflow model optimization toolkit, since this would greatly improve the usability of these models on edge devices like EdgeTPU.
This Framework aims to compare the development version to the baseline version . Upon each commit, several builds are triggered for various operating systems and build configurations. Each build status is then reported back to the developers in the Pull Request comment section on Git Lab. Each build creates artifacts containing the newly-built FreeType libraries for developers and users to download. There are also special pipeline phases called "Regression Tests" that run FreeType's built-in demo programs to compare visual outputs between commits. An HTML report that contains a table of the results will get uploaded as an artifact for these tests. For text output, an HTML page displaying a difference generated and for images, a special page is generated that shows both images, layered, so that you can mouse over each to see differences.
The Testbench is an important part of digital logic design. Testing circuits manually can be a big hassle especially for professors grading assignments. This project helps automate that process through a more robust Testbench engine tightly integrated with simulator and assignments.
The project aims for the following:
bdchecks may centralize available data checks, facilitate further development of novel data checks, improve user experience, and engage domain experts.
Software Heritage is an ambitious research project whose goal is to collect, preserve, and share all the publicly available software with its source code and development history. The Software Heritage archive is already the largest of its kind, having archived more than 10 billion unique source code files and more than 2 billion unique commits coming from more than 154 million software projects. The archive periodically crawls forges like GitHub and GitLab.com, distributions like Debian, and package managers like PyPI.
The archive has a search feature for the metadata and the repository URL. This metadata includes the name of the package, version, description, author info, etc. The archive search is accessible via the Web UI as well as the REST API. The goal of my project is to make the archive search more expressive and powerful which primarily involves changes in the archive web app(swh-web), the storage service(swh-storage), and the Elasticsearch service(swh-search). I will be implementing autocomplete for search-as-you-type, sorting, filters(by populating new elasticsearch index fields with metadata mined from archived repositories), and a search query language(optional).
My project will improve the existing API of the control module in sympy.physics. It lacks some basic functionalities that a control system module has, such as the State Space model and stability analysis plots, which will also be added.
OpenLex is a legal management system developed in web2py this system has the advantage that it can be run on any operating system thanks to the fact that it is a web browser application, however, for this reason it represents mistrust among users due to ignorance about the security and system integrity because this is used by a browser and not as a desktop application. In order to satisfy these users, the development of the installer in the different versions of linux, windows and apple is proposed in the project issues.
A simple identity authentication module has been implemented in the current panel, which supports the user name/password authentication mode, but its implementation faces some problems.
First of all, in the currently implemented authentication mode, the user name and password are stored in a configuration file in plain text. It does not support hot updates, nor does it support dynamic addition by programs, and it is also difficult to ensure security.
Also, the back-end part currently does not implement an abstract authentication framework specification, and can only implement a single authentication mode, which cannot be extended.
This proposal aims to implement an extensible abstract framework for the front-end and back-end so that it can be extended to other authentication methods while retaining the existing username/password mode and improving it.
With this project, P5.js website will have Hindi language translation. As P5.js helps the student learn new technologies it is good to have a diverse range of languages. This project will also improve the i18n engine for better translation across all languages. I will read and understand the codebase first and then I will start by making appropriate changes.
This project aims to improve the functionalities of the Apache OODT OPSUI React.js User Interface and implement a REST API for the resource manager component of Apache OODT. The current OPSUI React.js dashboard which has been developed in the Apache Wicket framework will be replaced with the React.js UI on the completion of this project.
In the past 2-3 years app development was mostly focused on adding new features and improving them. These features have significantly improved the functionality of the app. Currently, All basic features which help in investigating the user journey have been successfully implemented. Next development steps would be to improve the user experience, Such that all the features are used efficiently. Hence this year I would like to focus on improving user experience. I will introduce new layout designs and solve bug.
This project aims at improving certain existing UV editor tools and also adding some new features to better support workflows involving UDIM textures.
Bayesian nonparametric (BNP) methods offer more modelling flexibility by relaxing parametric assumptions at the cost of more daunting theoretical underpinnings and challenging implementation. PyMC3 is a Python probabilistic programming library for fitting Bayesian statistical models using Aesara - formerly Theano - as a computational backend for Markov Chain Monte Carlo (MCMC) sampling and variational inference. While PyMC3 provides built-in tools for plotting, model checking and a wide selection of statistical distributions, it currently lacks support for Dirichlet Processes (DP), a BNP method first that is garnening much attention from the research community in the last two decades. My Google Summer of Code (GSoC) proposal centers around bridging this gap in the PyMC3 framework by building a submodule for DPs and DP-related methods and contributing notebooks that build upon them.
Android FHIR Client is an implementation of the Android FHIR SDK in the form of an android app. This project is started to encourage adoption of the Android FHIR SDK and the use of best practices around its implementation. Therefore this project can become the standard implementation of the Android FHIR SDK.
Avogadro is being implemented as an alternative to Visualizing Molecular Dynamics to visualize the *.xyz outputs of the GOpt quantum chemistry geometry optimization software.
This project proposes to refactor and rewrite most of the production code and tests to Kotlin, implementing all the modern features designed specifically to streamline mobile development, replacing the deprecated parts of the code, and simplifying the assertion statements in the tests, resulting in safer and more maintainable code for future development.
The project aims at developing a feature wherein the template developers can sign the templates (authenticated the source) they developed. The contracts derived from the templates can be then signed by the parties involved in the agreement (authenticate the signatories).
I will be creating a web-based Artist Activist Toolkit that will act like a utility and a possible guideline for other artists, activists, and coders on how to narrate and visualize stories to advocate for important issues using p5. As a step-by-step example for activism through storytelling and code, I will be creating an interactive code-based visual narrative on a topic that I am currently passionate about which is to help the Asian American Community during these difficult times.
The Essential Care for Every Baby (ECEB) is an educational and training program, developed by the American Academy of Pediatrics, provides knowledge, skills, and competencies to nurses and doctors in low/middle-income settings so that they can provide life-saving care to newborns from birth through 24 hours postnatal.
The aim of this project is to develop an Android mobile application, the ECEB Digital Action Plan, that is purposely built to provide clinical decision-support for nurses and doctors delivering essential newborn care interventions during the first day of life.
This project aims to develop an ECEB Android Application with the following features-
The aim of this project is to integrate an automatic AI-based scheme into the gprMax environment such that it provides real-time FDTD solutions to the user. A Deep Learning-based algorithm can be used to provide real-time solutions based on the user's inputs, thus speeding up the computational process. An AI-based real-time EM solver will be orders of magnitude faster than conventional FDTD and would also alleviate the need for having heavy computational resources at the user’s end.
In practice, the goal is to develop user-friendly tools with which the user will be able to effectively parametrise the investigated problem and define the expected range of the parameters. Big data will be generated in an automatic manner to be subsequently used for training a deep learning scheme to predict the electromagnetic (EM) response subject to the parameters of the models.
The project aims to implement a fast finite element interpolation algorithm in Gridap.jl for any two functions belonging to finite element spaces defined on different domains. The method is based on the interpolation algorithm implemented in FreeFem. Support for computing the interpolation matrix associated with the linear interpolation operator will also be implemented.
My name is Bart (officially: Bartłomiej Rasztabiga) and I’m a student of Computer Science at Warsaw University of Technology (Poland)
The project I’m interested in: https://wiki.openmrs.org/display/projects/GSoC+2021%3A+The+REST+of+Administration
This project involves creating REST endpoints for managing administration functions that are not yet available via REST.
The goal of this project is to be able to render links to administration pages for install modules within a new (REACT-based) administration application.
Draft plan for completing the project:
TensorFlow Datasets is a collection of datasets ready to use, with TensorFlow or other Python ML frameworks. It makes the task of loading and using datasets much easier since it transforms the raw data into a standard format so that it can be immediately fed into the machine learning pipeline. TFDS currently supports several datasets as mentioned in their Catalog but scripts need to be written and reviewed for each dataset which is to be added. To overcome this limitation, Community Datasets, enables TFDS to leverage datasets in a different location by streamlining the process.
Key Goals:
tfds register NAMESPACE URLtfds list Add support for listing and filtering datasets The objective of the Visit the World Home edition project is to facilitate access to Liquid Galaxy or a private TV via voice commands, using an independent platform running on a Raspberry Pi4. The user in this case is intended for the elderly, and can use the platform to send KML to a normal Liquid Galaxy installation connected to the same network, or use this device connected to their TV through an HDMI cable, as a system independent. This device should be as simple as possible so that the user does not have doubts or difficulties when using it. To turn the device on and off, an easy-to-see and accessible button will be applied, later the idea is that it works as a voice assistance for Liquid Galaxy, it will only receive voice commands and it will not need more information from the user.
This project enables the edits made by the creators in the exploration to sync in the background so that the two creators can easily work simultaneously on any exploration. After this project, in case the versions of exploration on the browser and server don't match, the changes made by the user will be compared with the changes made in the backend by another user and if the changes are unrelated then the changes will be easily merged and if are related then the user will get a conflict error along with conflicting changes. This project will also enable the autosaving of the changes made by the user even if they are offline or the connection is flaky and then save their progress automatically when they have reliable network access.
Idea from list- Freechains P2P library in Lua, using the Luasocket library to interface with the Freechains daemon.
From ideas page:
Freechains is an unstructured peer-to-peer topic-based publish-subscribe system. Each topic, or chain, is disseminated peer by peer in the network with gossiping. This way, as an author posts to a chain, other users subscribed to the same chain eventually receive the message. Freechains supports multiple types of chains for public and private communication.
The goal of this project is to create a Lua library to interface with Freechains. The Lua interface should mimic the standard command-line interface of Freechains.
Refactoring techniques like function renaming have been applied in mature IDEs like Visual Studio, JetBrains IDEs. As an aiming of "One IDE to rule previous all,” Haskell Language Server(HLS) should also have this essential feature.
Inspired by this issue, my proposal involves five essential components in refactoring:
I hope I can contribute to HLS to go further this summer.
Music Blocks is a Visual Programming Language and collection of manipulative tools for exploring musical and mathematical concepts in an integrative and fun way. After years of development, patch work and bug fixes MusicBlocks was not maintainable anymore and could not upgraded to use new libraries and frameworks for better performance. This project is an effort towards the complete overhaul of MusicBlocks, rewriting it from scratch while maintaining a good standard of code quality and leverages modern JavaScript technologies and a better application architecture to ensure a smooth and reliable user experience.
This project aims to develop and improve the AnkiDroid Android App.
Here are the list of things which I aim to work on:
Onboarding
An onboarding flow will help users to understand the app and its purpose in a better way. This will contain details about the benefits of flash cards and spaced repetition along with examples on how to use them. We can also make use of tooltips and coach marks at various places throughout the app to provide guidance to new users.
Loading/uploading shared decks in-app
Feature to allow users to directly download decks in the app using download link, deck ID or deck name. This will update the current process of downloading the deck and importing it, thus making the app much better since users can easily search for decks using the deck name directly through the app.
Refactor the project
Migrate the project to Kotlin. Remove outdated libraries/APIs and use the latest alternatives.
UI/UX
Improve the UI and UX of the app. Implement the material design library in the app and improve the design of various features of the app.
Apart from this, I am planning to work on other things which come up during the GSoC period.
Design and implement a hook system to attach Lua scripts
Sisters of the Faldroid is a side scrolling 2-D action platformer game in which you play as a girl who is on her way to protect her sister, who was kidnapped by a really bad guy. The game will have 3-4 chapters with a certain amount of levels in each chapters. Each chapter will provide you some special ability which will help you to defeat the final boss. Game will take turns into different game modes such as platformer, flappy, arcade, shooting, strategy, mage etc so be prepared. It will have all type of crucial game elements such as power ups, story, action, fun, bosses etc and hence a game like this will truly shine the potential of Catrobat's Visual programming language.
Today, many fields of computational sciences (Data Science, Data Visualization and even Machine Learning), mathematics, engineering, geology and others make use of matrices. Usually described from tables, it is a central tool used by many programming languages. A tensor is a generalization of vectors and matrices and is easily understood as a multidimensional array. In the PolyMath project (a Pharo project that implements numerous mathematical algorithms), there is already a support for vectors (tensors with rank 1) and matrices (tensors with rank 2), but not general multi-dimensional matrices (aka tensors). The main objective of this project is to extend the existing PolyMath classes to support tensors and related operations.
Upmixing stereo sound sample to more than two channels. With this filter you get much realistic surround stage effects.
The project aims to add support for ns-3’s built-in logging to SEM, also allowing the user to visualize the logs on an interactive dashboard. The user will be able to enable specific log components at a specified log level for their ns-3 scripts ran with SEM. In addition to this, the users will be provided with an interactive table (with different filter options) and a graph to easily visualize the logs generated.
Bagvalal is an endangered typologically rare Caucasian language from the Nakh-Daghestanian family. Its conservation and study are constrained by the lack of sufficient NLP-tools that can be used to process field data. My proposal is to develop an fst-powered morphological analyzer for Bagvalal using all the available grammatical and lexical information. In the future this project can allow Apertium to support morphological analysis for multiple Nakh-Daghestanian languages and develop corresponding language pairs.
JMAP is an email application protocol to modernise IMAP, on top of HTTP using a JSON format. JMAP is designed to make efficient use of limited network resources and to be horizontally scalable to a very large number of users. Apache James is one of the first implementations of this new standard.
Mail user agents generally allow displaying emails grouped by conversations (replies, forward, etc...). As a part of JMAP RFC-8621 implementation (https://tools.ietf.org/html/rfc8621#page-20), there are dedicated concepts: threads. JMAP Threads is already implemented In Apache James in a rather naive way: each email is a thread of its own. This naive implementation is specification compliant but defeats the overall purposes of threads: emails which related to a topic should belong to a thread.
James’s data models, storage APIs, and some JMAP methods at HTTP level need to be changed to make sure the purpose of the thread is reached.
Example Zoo is an implementation of mlpack showcasing its potential usage in the real-world domain. It will provide a better starting point for new users to learn from ready-to-run code. It will showcase the usage of API, how it can be integrated with different visualization libraries for cool graphs and plots. The example will show the potential usage of Machine Learning Algorithms and Deep Neural Networks on real-life datasets. Finally, a well-documented process for creating an end-to-end machine learning project, using mlpack as a core.
The increasing parallelism brought by CUDA and GPU libraries benefits PCL as well as other open-source communities greatly. However, the test for these GPU-accelerated code is a bit awkward on those common CI without free GPU. Therefore, building a generic tool to allow CPU to run CUDA without a GPU is inspiring and valuable. And integrating this tool into the CI of PCL will bring more convenience and confidence to CI build.
The toolkits used in this project will also provide an option for AMD users to build and run CUDA codes in AMD GPUs.
This proposal aims to build a generic tool to allow CPU to run CUDA code, and introduce this feature to PCL as necessary.
Drakvuf-sandbox is a malware analysis tool that is used to analyze the behavior of the malware in a contained environment. It uses the Drakvuf engine as its backend for interacting with the malware and abstracts a lot of stuff out making analyzing malware easy and user-friendly.
Currently, Drakvuf-Sandbox only supports Windows-based Malware Analysis. The upstream Drakvuf also lacks the proper Linux support. Therefore, this proposal focuses on implementing the support for Linux-based malware analysis.
3 mostly unrelated smaller projects that all happen to start with "uni": UNIcode, UNIt testing, and UNIversal dependencies transfer (the latter being for fun and I might not get that far).
Currently, PEcAn is not available in CRAN, this makes it harder to install on systems since it requires the user to download all code first and install it. Adding PEcAn packages to CRAN will not only make it easier to install but also easier to find and easier to use standalone modules. This will require fixing warnings in the build process, removing unnecessary dependencies, and potentially splitting modules.
JabRef currently only has limited support to interact with pdfs. It can only read XMP metadata and cannot write metadata at all. Since pdfs are a common format to share scientific papers, this should be improved. With the help of the GROBID deep-learning library we want to extract the complete set of bibliographic data from pdfs and use it in JabRef!
I would like to help improve the web accessibility of p5js.org through adding alt text to visual elements on the p5.js website.
Over the last few years, the programming language Rust has seen a surge in popularity. This has primarily been the case due to its more robust memory management and faster execution when compared to C/C++. Rust’s features are advantageous while building scientific software since there’s often a large amount of data to analyse, and performance is one of the most critical concerns. Hence, Rust is now being applied to the development of bioinformatics tools as well. In the future, these tools will be increasingly used online, and implementation in the Rust language is expected to ensure the safety of these tools. This project aims to demonstrate the suitability of Rust to the development of a simulator for SBML models.
This proposal is related to the tool of code completion in this language. It focuses on ideas about how to enhance UX completion and also to analyze heuristics suggestions based on names analysis and also approaches based on statistics and a prototype that can improve the results of completion for the programmer.
PRocess MONitor (PRMON) is a utility programme used by the Worldwide LHC Computing Grid (WLCG) to monitor the resource consumption and performance of millions of jobs run by the ATLAS experiment in particular. The output generated is then used to detect anomalies in individual jobs or task groups. As the functionality of PRMON is extended, the complexity of errors that need to be tested and handled increases. Further, it is presently designed to read the data of processes while they are running. This project aims to implement a logging framework for dynamic and configurable logging. Further, the functionality of PRMON will be extended to read data from preprocessed sources. Each monitor will be adapted to read optionally from these precooked sources. The unit test infrastructure will be developed for testing against complex and unusual errors. Precooked sources will be generated to serve as unit tests consisting of these unusual cases.
The proposed project will create a fair-ground for service producers and consumers who employ intermediaries to engage with each other. In between producers and consumers, intermediaries hold a powerful position that can decide the monetary values of the services. Understanding the value of the intermediary-existence, it is proposed to mitigate this drawback using blockchain-based smart contracts where both producers and consumers hold control of transaction flow. The pricing mechanism will be transparent, yet privacy preserving. This would empower both producers and consumers and be the first step of the ultimate goal -- everything-as-a-service in the future.
The VideoLAN organisation has transformed the digital audio and media space since its inception over 10 years ago. The ease of use of its forerunning product, VLC Media Player, has made it the number one choice for millions of users around the world for viewing and interacting with media. Yet, despite this VLC Media Player’s design is relatively outdated. Users should be able to navigate around VLC Media player with ease, acting as an almost seamless extension of their body. Features should be readily obvious to users, not hidden in multiple menus so that they can be accessed quickly and easily. As an avid VLC Media Player fan, this forms the motivation behind my proposal. I propose to update VLC Media Player by leveraging Qt to design a more modern and elegant interface.
Specifically, I plan to implement multiple features into VLC Media Player which have been requested by the VLC community. This includes the addition of options to VLC Media Player disabling specific settings such as the ‘Continue Watching’ section, a clearer and more accessible way to display all tracks in a specific album and ,if time permitting, a new SMPTE widget to access more advanced settings.
StarFix is a cross-platform client-side application that would let you open a file in the Editor of your choice (vscode, eclipse, intellij, emacs, vi, etc.) and other commands locally directly from the browser or file system. This will enable an option to “Open in IDE” through browser extension on various websites like Github, Gitlab, etc similar to the one you see in this demo below. This season we aim to improve the existing tool by resolving the existing issues and adding new features that the user may need .
As part of GitLab's commitment to open source, features within Secure from the GitLab Enterprise Edition are making their journey to the Community Edition. Specifically, Secure aims to make SAST and Secret Detection available in GitLab CE. To make these features available in CE, it is important to make Sast and secret_detection methods available. As such, this project’s goal is to port Ruby on Rails modules through reallocating ruby files related to Vulnerabilities, Vulnerability Findings, and the parsing of security reports to be included as part of the CE distribution.
This project focuses on the CDLI journal workflow before we submit an article. Before the submission of journals it should be accessible for an open review process. To implement open journals in the system, an appropriate workflow needs to be developed which is intended to be carried out using https://pkp.sfu.ca/ojs/ojs_download/ software. In addition to this, we intend to make further integration in the framework regarding endorsement of reviewers with published articles.
This is a proposal for the design and implementation of an animation API for libadwaita, as the GNOME ecosystem lacks a framework to provide meaningful animations for its apps. This API would allow for easy animation implementations from the app side and better and more maintainable code for where animations are already implemented (namely, libadwaita itself)
Translate the Matlab examples listed in the pyprobml to Python, using JAX and test the examples to make sure they work with the existing Colab notebooks.
MDanalysis (MDA) is a powerful open-source package for exploring and performing calculations on molecular dynamics trajectories. Despite MDAs broad utility, especially for biomolecular simulations, it does not implement many common operations for studying ion solvation. I propose adding a robust and cohesive set of methods for solvation analysis that would be widely useful in both biomolecular and battery electrolyte simulations. The core of the solvation module will be a cohesive set of functions for easily working with ionic solvation shells. Using that core functionality, I will implement several analysis methods for analyzing ion pairing, ion speciation, residence times, and shell association and dissociation.
Currently, DeepLense supports the following models for unsupervised dark matter classification:
- Adversarial Autoencoder
- Convolutional Variational Autoencoder
- Deep Convolutional Autoencoder
- Restricted Bolzmann Machine
Most of the listed models are surrogate base approaches. While surrogate approaches have become the mainstream method for anomaly detection in recent years and have shown promising results, it is hard to ensure that the surrogate tasks share a consistent optimization direction with anomaly detection. The proposal offers to return to a direct objective function for anomaly detection, which maximized the distance between normal and anomalous data in terms of the joint distribution for image and feature representation. The above objective function is decomposed into the following fours components:
- Mutual information between image space and latent space of normal data.
- Entropy of normal data in latent space.
- Expectations of cross-entropy between normal and anomalous samples in latent space.
- Distribution distance between normal and anomalous samples in image space.
Spoon is an open-source library to analyze, rewrite, transform, transpile Java source code. It parses source files to build a well-designed AST with powerful analysis and transformation API. It fully supports modern Java versions up to Java 11.
Spoon has a lot of methods whose testing can be improved. For many methods, deciding an arbitrary return value doesn’t change the test results.
There is a full list of pseudo and partially tested methods which need improvements in testing. This list contains around 240 methods whose tests need improvement. Apart from this, there might be some methods that aren’t on that list and need addition/improvements in testing.
Although around 240 methods need improvements in tests, I believe it may not be feasible to improve all 240 in a limited time.
I am planning to add/improve tests for 30-40 or a pre-decided number of methods under this project. I may improve the rest after the program ends.
Currently Paintroid only has the basic brush and the spray can. The goal is to add additional brush options such as a watercolor brush, rubbing around existing color. Also, when drawing a little bit faster, the drawing line should be slightly smoothed. When drawing slowly, it should however be possible to draw without smoothing of the lines. Also, add an option in the brush settings that allows to turn off (and on again) antialiasing, independently of the width of the brush. Currently, antialiasing is only turned off if the width is set to 1.
Late last year, OpenMRS began collaborating with researchers from North Carolina State University (NCSU) to better secure the OpenMRS Reference Application. NCSU researchers, using cutting-edge security assessment techniques, have identified almost 300 distinct security issues. At the same time, many OpenMRS developers and some implementers know about these vulnerabilities but maybe because of scanty of organized security documentation and/or low numbers security experienced folks in the community, is why they haven't been rectified.
This project aims to extend the existing functionality("fesErrorMonitor") of the p5.js Friendly Error system and add a new feature that will allow the Friendly Error System to read the user's code, analyse it for mistakes and log a friendly message for the same.
This project aims to improve the Reference Image Tool in Krita to include some additional features that will be helpful for the users .With this project , users would be able to directly interact with the reference images and modify them accordingly with Krita . It includes
Pin Reference Image - a new transformation to prevent canvas modifications to them .
Integrate crop functionality for them .
Update & sync the reference image when image is modified on the hard drive .
This project aims to integrate the Makie plotting ecosystem for the Julia programming language within the library Gridap, used to approximate partial differential equations, thus creating GridapMakie. The implementation will entail an improvement in workflow, not relying on external software for grid or data visualization. Moreover, the interactive features of Makie make it the suitable choice to observe any changes of parameters in real-time. Such integration will be performed employing Plot Recipes, a macro defined to customize plotting commands. Therefore, the goal of the project is to develop, document, and release the GridapMakie package under the Julia official registry verification.
Currently EOS delivers icons via a set of well documented methods, which chiefly include EOS-Icons Package, CDN or direct download of icons in SVG/PNG formats. This project will be based on developing an npm package that can deliver EOS Icons to its users as an independent component library and create a unified central system that will enable EOS to deliver its icons to various frameworks (e.g. React, Vue and Angular) independently. This npm package will be as lightweight as possible in order to reduce the load put on the browser (using the tree shaking approach), which will result in providing a much smoother workflow to the users. Creating a central package of EOS Icons that can supply icons across React, Vue and Angular frameworks will go a long way in having a more consistent user experience as well as boost capability to accommodate users who migrate from one framework to another.
This proposal fulfills the need for continued development of the Swift Processing code base. This means that bugs would be fixed and more user-friendly abstractions of Apple's API would be added. Swift means that Apple's hardware can be leveraged like the camera, sensors, and GPU. This creates opportunities to support Metal (Apple's graphics API) within Swift Processing or OpenGL ES, as is the case with Processing. AR Kit, Apple's augmented reality API, is another possible item that might be included. I am a computational artist and designer as well as an iOS developer. I have taught Creative Coding to a very diverse student body at the community college level since 2015 and with Swift since 2018 using various frameworks. For this I've "flipped" courses and built out asynchronous online courses with videos and tutorials. My experience teaching Swift has given me insight into what makes an API and its examples/tutorials successful. Swift creates unique challenges for new learners. Being involved in this project would allow me to contribute in a way that makes a difference and makes Swift more inclusive and accessible to the creative coding community.
As MusicBlocks is being refactored, this gives us an opportunity to revisit several UX issues, including designing and implementing the menu bars and block palettes. I would like to design the wireframes of the new musicBlocks and implement them in React + Typescript so that all UX issues are resolved, and users can easily navigate through the palettes and menus.
Android and its development tools are free (as in freedom) software, so the Debian project wants to compile and package Android SDK software for their distribution, allowing such software to be well supported by the distribution. Also, the SDK unfortunately is under a proprietary license for its binaries, which adds to why Debian is interested in making their own packages, as their packages would be free software and friendly for projects like Replicant.
My part in this project would be to help in the development of Kotlin and Gradle packages for Debian. Debian's Gradle package is at version 4.x, when Gradle currently is at 7.0. Kotlin's package is absolutely non-existent on the other hand and only is a a Debian package repo on Debian's Salsa Git site. Kotlin and Gradle are both necessary for further porting and development of Android tool packages on Debian and would also go a long way too for other JVM-related developments on Debian too, due to the popularity of Kotlin and Gradle.
This project aims to add new features to ABioTrans Plus(GeneCloudOmics) that includes the direct import of gene expression data from Gene Expression Omnibus (GEO) databases, creating a detailed report with the performed analysis with figures and data ready to be included in the publications, add more gene expression analysis methods e.g. Gene Set Enrichment Analysis (GSEA) and adding more sample comparison analysis and plots. Provide Docker support.
Joplin already supports templates however we would like to re-package this feature as a plugin. Thus you would remove it from the main app and create a new plugin for it. It should be compatible with existing templates. Once the plugin is created, it could be a good idea to improve the feature further, perhaps based on user feedback on GitHub or in the forum.
Apache ShardingSphere uses ANTLR (ANother Tool for Language Recognition) as a generator for the SQL parser engine and obtains SQL statements from AST (Abstract Syntax Tree). Currently, the ShardingSphere parser engine has basic Oracle DML SQL definitions but does not align with Oracle documentation.
This proposal suggests proofreading Oracle DML SQL definitions and corrects them according to Oracle documentation. This will be achieved by:
Once the ShardingSphere parser engine is aligned with Oracle's DML documentation, the users and developers of Apache ShardingSphere can parse a complete set of Oracle DML SQL statements.
directlabels is an R package for adding intuitive text labels to plots, typically in order to replace confusing legends in lattice and ggplot2. This project will incorporate several modifications to this package which will make it more attractive and convenient to use/test this package via better documentation and tests.
The improvements include:
• Creation/Configuration of software for automatic generation of a new documentation website (hosted on GitHub pages, instead of the current r-forge domain), thus removing the need to re-compute the docs manually. (I'll be using a combination of dldoc and GA-based workflows)
• Addition of directlabels to the ggplot2 extensions gallery.
• Refactoring the codebase to make it eligible to exercise grid.force by using the new (Rversion >= 3.0.0) grid hook methods and by making changes to the functions affected by this transition.
• Setting up code coverage (possibly automating this as well) and a proper testing framework, with tests based on the grid graphical objects which are exposed via grid.force from the transition to the makeContent hook.
In this project, I will be building a unity plugin that runs the MediaPipe Holistic model to do animation of a rigged 3D model as shown on this link. The Holistic model is indeed a great model by MediaPipe. Over a period, I have noticed a sudden rise in its demand in Unity XR projects since it provides the accuracy, FPS and features that no other competitor possesses. As of current technology, this can be still implemented with unity barracuda or TensorFlow or posenet. But none of these technologies is having support for cross-platform and mobile development having a decent FPS on an average device.
CernVM-FS (CVMFS) is a service for fast and reliable software distribution on a global scale. Data is organized in repositories. Files and metadata are downloaded on-demand by means of HTTP requests and take advantage of several layers of caches. The current per-file granularity of distribution and caching leads to poor performance especially in case of cold caches. In particular, loading of interdependent files and libraries required for certain applications can be improved. The goal of this project is to introduce the concept of bundles, which would improve the startup performance of applications.
In PEcAn, there are data processing pipelines that prepare data as model drivers, as well as constraints. Flux tower networks are one of the most important sources that collect such data. The aim of this project is to add the Integrated Carbon Observation System(ICOS) data stream to PEcAn. This would provide a wide variety of input data for running the ecosystem models, as well as constraining them in the European environment. Additionally, this project aims to add a GEDI LIDAR data stream to the remote data module.
The project aims at migrating WebStatus from Python 2 to Python 3, fixing internal defects and improving usability.
Give homeserver admins the ability to restrict who can register an account by requiring users to submit a token during registration.
Gitmate, a git workflow management bot created by coala, hasn't been actively maintained in the last 3 years. My project aims to update it and bring it back to active use for the coala community. I plan to undertake various improvements to Gitmate as well as IGitt, the underlying library that powers Gitmate's git operations.
My primary goal is to set up Gitmate for the coala community. I will also upgrade both Gitmate and IGitt to the latest API versions of Github, Gitlab and Jira and add support for the latest python versions by upgrading the dependencies. Along with this, I will update various aspects of the documentation of both these projects, improve testing, and ensure that the Continuous Integration setup is in perfect condition. The last phase of my project will involve merging three pull request plugins into a combined plugin and improving various pull request events. Throughout the project, I will work on feedback from the coala community and try my utmost best to improve their experience with using Gitmate.
To revamp current eventyay site into new one from Emberjs to React with NEXT and setup frontend modelling ,similar UI-UX behaviour, write tests and maintain quality code.
The AXIOM recorder software can record moving images from axiom cameras via either USB3 or Ethernet. Currently, that software is only a CLI tool that is difficult to use in the field and has severe accessibility hurdles for not technically inclined users. This project will develop an easy to use and performant GUI to ease the operation of the recorder.
The open-source RISC-V instruction set architecture is gaining interest throughout industry and academia. One advantage of RISC-V is the ability to add custom instruction extensions to the processor targeting specific applications. A joint project between Embecosm and Southampton university recently developed an open source ISA extension for the CV32E40P RISC-V core to accelerate neural network inference acceleration (https://github.com/AI-Vector-Accelerator). The verification of the AI vector extensions project currently exists only as a Verilator model, and speed ups are based on cycle counts, with no insight to any impact on clock speed in actual silicon. There is no pipeline and everything is single cycle because there are no timing constraints in Verilator. This project aims to take the existing work and bring it up on a Nexys A7 FPGA platform.
Talawa needs both UI and UX Improvements. The current UX is different from what is stated in Official docs. The color scheme is not pleasing and also a dark theme is needed. As stated on the ideas page, people of different age groups and backgrounds will use Talawa and so the App’s UI needs to fit the requirements of the majority of people. For this, the App’s UI and UX needs to be designed in such a way that people find it easy to use. Currently, for new users, it’s difficult to understand the ideas behind certain UI elements as well as the motivation behind App’s features. The UX should be seamless and people should quickly get habituated to use the app. UI should convey more information pictorially through a combination of colors, Icons, and Text.
Freifunk Client Steering (ff_steer) Current Access network lack fast client handovers and roaming. Lately the client handover daemon “usteer” was released and focuses on none-standard client handovers by disassociating client and manage an intra AP communication to enable roaming. More recently the DAWN project uses a decentralized WiFi controller approach to disconnect clients based on RSSI measurements and statistics. Apart from this the IEEE 802.11v amendment is very promising. It allows a better handover of 802.11v enabled clients between APs. Instead of disassociating, the client can be guided to the next AP using a BSS TMR frames.
The goal is to create a light-weight user-space daemon to enables IEEE 802.11v client handovers between OpenWrt APs. The steps are (I) to distribute the neighbor hearing map between relevant WiFi APs within a L2 domain, (II) manage client roaming with a new OpenWrt UBUS based interface and (III) validate and evaluate ff_steer with experiments.
My proposal can be split in three phases:
The project is aiming to develop a GUI for the simulations of reinforcement learning so that users, particularly, the researchers can be able to test and implement their ideas and algorithms about reinforcement learning with the embedded environments easily even though they are not able to implement the codes in a fast way. The GUI will involve an interface that is encompassing graphical blocks which should be clickable by the user. Users will be able to create an execution flow by selecting the graphical blocks which are referring to the selection of the environment (e.g. CartPole-v1, Acrobot-v1, etc.) and the algorithms. Furthermore, the relevant information such as Q-values, reward functions will be shown on the GUI at any time during training and testing.
At present the user can only visualize the 2D datasets and can even generate one of them. So, my major approach in this project would be to create an user interface as WPS service within MapMint such that the user cannot only visualize the 3D dataset but can also build the same. This can be done either through either simply capturing via camera or importing drone captured images. Further I am planning to integrate the various functionality as a toolbox to process the 3D datasets and 2D datasets as well. If time permits the various additional functionality such as enhancement, smoothing, sharpening, brightness control will also be implemented.
In this project I'm going to continue developing translation pair between Uzbek and Qaraqalpaq languages. In the list of different pairs of Turkish languages, I analyzed that these languages are very large and vast, so I think that the development of translation of these languages leads to improvement. I hope that, I will help to continue translation pair between these languages and it will be useful for all.
Pg_systat is 'systat' for PostgreSQL. It allows users to monitor various PostgreSQL statistics tables from a terminal window. This project aims to add monitoring of pg_stat_statements to pg_systat.
SMART-on-FHIR has been built into the major EHR products and has been used by many healthcare institutions. We already have the SMART-on-FHIR module, but we need to add a patient and encounter context launch to support the fully functional SMART launch. This project focus on the development of the SMART-on-FHIR and Keycloak-SMART-auth module. A Demo SMART App will also be developed.
Currently Cassandra can create snapshots of SSTables containing all data of concrete Column Family (Analogue of the table into RDBMS).Snapshot is a copy of original data, represented by the hard link.They can be created before each compaction or before keyspace truncation.User also can manually create snapshot via nodetool snapshot command. After snapshot creation it is not managed by Cassandra.The goal of the task is to make it possible to set TTL to snapshot and automatically delete it after it’s expiration.
Nginx is the second most popular web server and the most popular among high-traffic websites. OpenResty is a high performance web platform extended from core Nginx and supports integration of Lua modules. Though still there is a lack of any specialised solution for authorization based on access control models. This real need can be addressed by Casbin perfectly since it supports the 3 major access control models (ABC, RBAC, ABAC). This project aims to implement Casbin’s functionality entirely in Lua and support it as an OpenResty module.
The project focuses on parallelizing existing modules that can benefit from parallelization with OpenMP, such as r.neighbors, r.mfilter, r.univar, r.texture etc.
The objective of this project is to keep Sugarizer growing by enhancing two core concepts for our deployments: Security and Availability. To enhance user's security features such as TOTP registration feature to Sugarizer School Portal and Sugarizer Dashboard will be added. Move "Presence" our Websocket based communication channel to High Availability by switching ram storage to Redis cache. Allow Hardware keys to be used to replace TOTP.
The main aspects of the project are to integrate CircuitVerse as a plugin to Moodle and publish CircuitVerse an LTI provider tool such that it can be added in any of the LTI supported Learning management systems like (Moodle, Canvas etc.)
The three major development goals of this project are given below
For the first two parts, a number of UI updation will be done on the CircuitVerse site to provide a user-friendly tutorial-based approach to install the plugin and set up the LTI properly in the corresponding LMS sites. This new integration will not suppress any of the existing LMS features of CircuitVerse, just some minimal UI updation and backend change will suffice for the new integration. Google Classroom Share integration has been already developed and there are lots of opportunities to enhance this feature in near future.
The project is about displaying data about the simulations in the view-port so that users and developers can easily understand what is going on. Data such as the individual forces acting on a rigid body, acceleration, velocity, etc. will be displayed. Constraints and cloth spring data will also be visualised in the view-port.
Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. This enables users to use Enzyme to perform various algorithms such as back-propagation in ML or scientific simulation on existing code for any language that lowers to LLVM. Enzyme does so by applying the chain rule to every instruction in every function called by the original function to be differentiated. While functional, this is not necessarily optimal for high-level matrix operations which may have algebraic properties for faster derivative computation. Many programs use BLAS libraries to efficiently compute matrix and tensor operations. This project would enable high-performance automatic differentiation of BLAS and similar libraries (such as Eigen) by specifying custom derivative rules for their operations.
At the end of this Google Summer of Code project, Enzyme should be able to automatically calculate the optimal derivatives of several common linear algebra functions, thereby implicitly allowing easier integration of Enzyme in several mathematical computing libraries.
This Project is about quantifying the quality of the Validation Tests (CerebTests), a part of CerebUnit Ecosystem for validation tests which needs to be implemented as a sub-module in CerebStats, another part of the CerebUnit ecosystem for statistical functions.
ImageJ is extensively used in major areas of biological and material sciences. Previously developed active segmentation platform as a plugin for ImageJ incorporate Weka toolbox-based statistical machine learning algorithms as well as deep learning techniques for trainable image segmentation. The end goal of the active segmentation platform for ImageJ is to provide researchers an extensible toolbox enabling them to select custom filters and machine learning algorithms for their research. Under the existing implementation of the active segmentation platform, it only supports users with a limited way to load the ground truth for learning ( at the moment only as of the region on interest format (ROI)). Thus, this reduced the usability of the tool and it urges the users to convert the ground truth to the specific format which is designed to be used within the application. Therefore the main contributions under this project will be to incorporate several ground-truth formats as image-based in which each pixel uniquely belongs to a particular class, partial ground truth format in which instead of the whole image and several partial boxes in an image or stack are labeled.
Artists usually work with multiple layers for a single element in their work (like lineart, colors). So there are cases when they want to apply similar operations over multiple layers. Having KDE's Krita (a digital painting platform) the ability to process these types of operations gives a heavy advantage to it's users.
Goal of this project is to provide Krita, the ability to apply basic operations on multiple layers/groups in a single key-stroke.
Tree ensembles are arguably the best class of machine learning algorithms out there. They regularly win the competitive data science competitions.
This project aims to implement the XGBoost algorithm to improve MLPACK's tree ensemble support.
This proposal aims at adding support for Redis to be used as a caching backend with Django. As redis is the most popular caching backend, adding it to django.core.cache module would be a great addition to the developers who previously had to rely on third party packages.
Currently, the agora-web API fetch/write data to the mongoDB. The aim of the proposal is to migrate voterInfo, candidateInfo and vote count records to the ethereum block chain using smart contracts. An interface will be provided to web and android clients to fetch/write data directly from block chain.
Polly uses custom C++ bindings for isl (Integer Set Library) which is a library written in C. I aim to replace at least partially the usage of these custom bindings in favor of the official isl ones. Unfortunately, this is not an in-place replacement. Differences include how errors are checked, method names, which functions are considered as operator/constructor overloads and the set of exported functions.
Hybrid fuzzing is a term used to describe techniques in fuzzing which involve concolic execution to drive the fuzzing campaign through difficult-to-reach parts of the target program. In the academic world, this concept has received a lot of attention in the past few years and the results are promising. However, so far this technique does not seem to have escaped the lab yet, with many academic projects being difficult to use in practice. AFL++ and LibAFL are projects that aim to make cutting edge fuzzing research usable in the real world and in the same vein, this project proposes to make hybrid fuzzing more approachable by providing the necessary components to do hybrid fuzzing with LibAFL.
re2r is a great R package that was rejected from CRAN , the goal of this project is to solve all the warnings that led to it being rejected and return the package back on CRAN.
Adding support for archive storage (i.e in the form of .zip or .tar.* family) of models for all pre-existing models in DFFML and update tests, documentation and fix any model specific bugs that come along the way while implementing this feature. This will not only save the model state but also all the configuration of a model. There would be two benefits of this implementation to the user:
The project aims at implementing the VRP functionality in the vrprouting repository of pgrouting, using VROOM as a library in C++.
VROOM is an open-source optimization engine, that aims at providing good solutions to well-known Vehicle Routing Problems (VRP), such as:
I propose to implement this functionality as an extension to PostGIS, the PostgreSQL geospatial database, by porting it to vrprouting, so that this functionality can be used in the PostgreSQL database.
Project Goals
libmixer(3) is a new FreeBSD library I’m proposing in order to interact with the sound mixer in a more extensible and easier way.
Symbolic Pathfinder (SPF) is a software analysis tool that combines symbolic execution with model checking for systematic generation of test cases that achieve high testing coverage. But symbolic execution and dynamic symbolic execution does not scale to real world software due to the path explosion problem. Java Ranger is a path-merging extension of Symbolic PathFinder (SPF) which extends the ideas of veritesting. Java Ranger translates a bounded control flow region into a single constraint (static summarization) to solve the path-explosion problem. While path merging should ideally reduce the number of paths by collapsing some of them, it has the side effect of introducing more symbolic variables into the state than traditional symbolic execution. This can cause at least two problems, (a) solving constraints in path merging becomes harder, and (b) the newly introduced symbolic state variables can cause additional forking depending on whether they were used in the subsequent branches or not. In this project, I propose to implement some heuristics inspired from to improve SPF's performance when it uses path-merging but avoids path-merging when it doesn't seem beneficial.
Introducing the Augmented Reality experience in the present MapMint4ME project and working on Better UI and UX part for the Augmented Reality Experience.
I propose to implement several metrics based on differens features of video such as color histograms, edge information, geometrical transformations etc. It is also useful to implement separate metrics to detect flashes so the algorithm would be invariant to them. The final algorithm will take into account the features with the greatest contribution to accuracy. It will also be possible to vary the speed of the algorithm by changing the calculated features.
The main goal of this project is to develop an IIO driver from scratch for the AD7294-2 device and have it on Linux kernel tree. The driver will be developed in small incremental steps, gathering feedback from the mentors and community in each of them to ensure high quality code. A secondary goal of the project is to log the development process and post about the IIO/GSoC experience, hopefully motivating newcomers to get involved with Linux kernel development, specifically in the IIO subsystem.
The project includes porting MicroPython and CircuitPython support to the BeagleConnect Freedom Device as well as writing drivers for interfaces like GPIO, I2C, SPI, PWM, UART and ADC in Micropython.
The current HPX Parallel Algorithms do no support vectorization. This project aims at providing vectorization support to Parallel Algorithms with OpenMP as backend.
This project is about preparing a dashboard that can show an admin the visual assets of the digital library for each artifact but also add, edit, delete, images using our archival images serve as a source of better quality images to prepare their web counterpart. Access to images should also be managed there (some images are not public).
The memory to CPU bottleneck is one of the fundamental and essential issues of commodity processors. With sweeply increasing computing speed, instructions might spend much of their time in waiting queues during read-store access. Nevertheless, there are also many available OS and microarchitecture designs for solving this performance complication. One of the important is the multi-level Translation Lookahead Buffer(TLB) Implementation. Based on the cache locality principle, it aids to keep the frequently used address translations near the core, hence amortizes the waiting time for instruction fetching and load-store units. With many levels in place, the less is the frequency of misses, the better is the performance. Thus, this proposal will aim to enhance the current TLB structure of the CVA6 (Ariane) core to a multi-level with L2 TLB on top of the existing L1 TLBs.
Here, CVA6 is the application class and Linux bootable 64-bit RISC-V 1.7GHz CPU Core. It is also addable to the OpenPiton Heterogeneous Multicore Research Platform.
The Testing Dashboard project aims to develop an easy-to-read dashboard with features like a status board to check which inputs are working and which are down so that it will be easy to monitor the tests’ results. On the backend, it will feature running the sandwiched integration tests on some appropriate schedule.
In the age where keyboards are more effective at causing damage than weapons, most cyber-attacks are detected too late to be effectively defended against. Therefore, we must resort to proactive measures to prevent, rather than wait for such attacks to happen.
Many hackers spend their time exchanging information on the dark web learning from each other. This is done in obscure forums inaccessible to common folk . If the data produced by such forums is collected and analysed, we could be able to fix the cracks in our web infrastructure before any damage can be caused.
My aim is to map the dark web using a smart crawler, find sites and forums similar to DarkNet, extract their information and dump it in a form suitable to be evaluated by ML and NLP techniques to analyse the threat they pose.
Smoothen, expand and refine the various geographical features under the Public Lab's website. This includes standardizing adding new leaflet environmental layers, increasing content on https://publiclab.org/map and various other refinements
The GStreamer libcamera element allows libcamera to be used in GStreamer pipelines. libcamera supports simultaneous streaming, for example having lower quality one stream for preview, while another higher quality one is used for recording. We would like to extend support for the GStreamer libcamera element to support this multistreaming.
hydrus is a set of Python based tools for easier and efficient creation of Hypermedia driven REST-APIs. hydrus utilises the power of Linked Data to create a powerful REST APIs to serve data. At the moment, hydrus does allow POST operation on hydra:Collection, but new functionalities should be added to effectively update, get or delete particular members from a Collection without actually sending the whole collection in the request payload. The flagship server hydrus can only serve static data and does not provide a way to define custom server-side logic. A new feature for dynamic endpoint could be added so that a developer would be able to define logic/functions for how the incoming data is processed on the server end. A lot of improvements are possible in CRUD operations of hydrus, including setting up constraints and handling errors on the server-side depending upon how the data is stored in a Collection. The project also aims to enhance the functionality of hydrus, optimize existing codes and keep it synced with upgrades and development in hydra-python-core, hydra-python-agent, and Hydra specifications.
Installing OpenCV on Windows has always been a gruesome procedure for beginners. Added steps of having to build the library by oneself using cmake and gitbash (for windows) makes the procedure difficult. With package managers like Nuget, which readily integrate into developer workflows and allow a simple one-time installation; the build tasks are automated to a great extent.
This project aims at creating an OpenCV package on Nuget & bringing support for automated deployment to it - such that the Nuget package updates every time the core OpenCV project has an update.
This project aims at making Zulip better by working on features which users in large, high-traffic organizations will find valuable. This mainly involves fixing bugs and implementing and/or completing new features in zulip server project in the notifications and stream-settings area.
By opening an unknown flowgraph file in the GRC you expose your system to arbitrary python code being evaluated via the block parameters. A View-Only Mode could remedy this by first providing a view where evaluated parameter values are saved to and loaded from the file instead of being evaluated until the users chooses to trust the flowgraph. The proposed project aims to implement such a mode in a secure and convenient manner.
This project is based on the idea Improve pure Elm markdown parser. As the idea described, some specs of the pure Elm markdown parser dillonkearns/elm-markdown are not yet implemented. So, the goal is to complete the current implementation of Github-flavored markdown style, get the automated spec tests passing, and clarify places where it needs to diverge from the spec because of its specific handling of HTML for extensibility.
With the increasing number of satellites launched into space, orbital congestion is escalating ever-more rapidly. This eventually increases the probability of a variety of space events where some might be catastrophic while others serve as a source of beneficial information of scientific interest. As a result, it would be advantageous to detect such contingencies. The potentially harmful ones like orbital collisions can be prevented, and others would allow us to extract meaningful insights about the satellite dynamics. This would ultimately assist in devising optimal orbital design and maintenance strategies.
The proposed project aims to add event detectors by implementing raw orbital algorithms allowing for increased efficiency and enhanced functionality and configuring them in high-level API. This would ensure swift processing of computationally intensive algorithms while simultaneously allowing to render an easy-to-use API to the user. Consequently, it would allow us to promptly recognize various intricate orbital mechanisms and formulate effective policies based on the outcomes.
This will be a standalone library to display multiple versions of any selected OSM element and allow comparison between the different versions.
Our challenge is to finish the remaining work to move Puppeteer’s Documentation into a documentation that will update its content with any new change that will be committed nicely!
The Project aims at contributing to the stability of Polypheny by writing test suits for the SQL, REST and User Interface as well as adding a testing framework for Polypheny-UI. Along with adding documentation. It aims to increase test coverage and make it easier to add tests in future and to reduce the number of bugs introduced accidentally.
QEMU supports exposing block devices to the guest OS over the virtio-scsi protocol. Currently, this is implemented using C code running in the main QEMU process. There is also support for using an external backend over vhost-user-scsi, but the existing backend is implemented in C, and is fairly limited, only supporting iSCSI.
The goal of this project is to implement an alternate vhost-user-scsi backend in Rust. This would provide benefits to security, reusability, and performance.
This project adds support for dump and restore of io_uring instances. The three main goals of this project is to handle dump/restore of empty io_uring, dump/restore of io_uring with completed events and no inflight events, and dump/restore of io_uring with in flight as well as completed events. The ring buffer needs to replay unconsumed entries on restore in a way that is transparent to the application. This project achieves these objectives.
project involve adding new transformations to spirv-fuzz tools to improve their support for compute shaders
This project focuses on the study and implementation of Graph Neural Networks (GNNs) for low-momentum Tau Particle Identification using the CMS Open Data. The algorithm will further be deployed on CMSSW (CMS Software) inference engine for use in reconstruction algorithms in offline and high level trigger systems of the CMS Experiment. The project also aims to compare the results of GNN based algorithms with the CNN (Convolutional Neural Network) based algorithms for tau particle identification. Finally, the graph neural network algorithm will be scaled to multiple GPUs and optimised accordingly for efficient training and inference using heterogeneous computing. The final inference performance on the CMSSW inference engine will be benchmarked facilitating the end-to-end low-momentum tau particle identification.
My GSoC'2021 Project aims to attain the following:
In this project I am working on integrating the Proactive data Containers with Ceph Rados with the help of Configuring the librados (Library file which allows us to access RADOS) as the RADOS object storage layer within Ceph is an ideal target for storing PDC objects. The Language to be used is specifically C/C++ for developing the commands to map the objects of the Proactive Data Containers to the RADOS pools.
The field of deep learning has had numerous impressive advancements over the last few years. Music generation has always been a difficult application of deep learning to make sufficient progress in. Recently, with the advent of attention-based Transformer networks, there have been substantive improvements in the automated generation of polyphonic music. With these advancements in mind, it calls for a need to enhance the support for Music generation and related research in the Julia language. I propose to implement the Music Transformer (Huang et al.) and provide an additional package NoteSequences.jl which would play a crucial role in speeding up the development of further music related projects in Julia.
The current TensorFlow model garden lacking the pose estimation model based on the paper named Distribution-Aware Coordinate Representation for Human Pose Estimation . The main goal of this project will be implement the paper results using TensorFlow 2 deep learning library and publish the model in to the TensorFlow hub. The implementation will be done during Summer as the part of Google Summer of Code program,Following are the expected outcome of the end of the program • The fully functional deep learning model training framework written in Tensorflow - python. • Implementation of proposed model DARK with base model architecture of Hourglass, SimpleBaseline and HRNet with different configuration and validate result produced in the paper. • Hyper parameter optimization of the developed model. • Performance evaluation of the models on different hardware. • Publish the final frame work and trained models in to TensFlow Hub.
"ghc-debug" is a heap profiler tool for GHC that pauses the current program and lets you run your own custom analyses on the heap. My proposal is to make it possible to easily convert the output from common forms of analyses (censuses, histograms, and graphs) into visualizations.
Description: rebuilderd is a verification system for binary packages. It repeats the build process of a package in an identical environment and verifies that the package is identical. It is part of the Reproducible Builds effort and can currently be used to rebuild Arch Linux packages. The rebuild must optionally generate in-toto link attestations which can be used to verify the entire process. To that end, the nascent in-toto-rs library must be developed to enable this integration with rebuilderd.
A formal power series is a (potentially) infinite sequence of coefficients. It turns out to be practical to denote it as an infinite series, although it does no longer represent a function. However, the usual operations on power series, such as addition and multiplication, can be given combinatorial meaning, which makes them an indispensable tool in discrete mathematics. Lazy Formal Power Series are an implementation of the Formal Power Series for a computer where coefficients are only computed on-demand, to deal with the problem that we can store only a finite amount of information. SageMath has an implementation of the Lazy Formal Power Series in the combinatorial species code. The project aims to disentangle the code from the unrequired submodules and create a robust structure. Another aim of the project is to implement Puiseux Series and bring in the implementation of the Laurent Series code into the same module. There are also bugs in the code that computes the coefficients of series which are defined implicitly by a system of functional equations. Fixing these is another milestone. A detailed list of issues and tasks can be found in ticket #31651 on the Sage Trac server.
Newt supports the Process Description (PD) and the Activity Flow (AF) graphs of SBGN. However, there is no conversion between these two graphs in the Newt. PD is a detailed version of AF. Thus, from PD, AF can be obtained but not vice versa. There is already a library for converting PD to AF. The goal of this project is to host a service for this converter and then integrate it into Newt.
Agora Android application runs smoothly and works fine with all the functionalities. This summer I am planning to add a Welcome screen for the new users and use the spotlight feature to guide all the new users with every feature in the app. The major fix will be memory leaks, which hinder a lot in the app performance. I am going to enable deep linking and allow users to vote through the app itself. Adding a search bar and a sorting feature is on my to-do list. Manually adding every voter and candidate can be hectic for a large list, so I plan to make it easier by importing these data from .xlxs files. I will be adding many more visualization techniques in the Result Activity and also export the result in .xlxs format to external apps. I will connect the application to Firebase, and enable crashlytics, analytics, and Firebase Cloud Messaging for better app retention. In addition to this, I am planning on multi-theme support and writing unit tests for all the business logic implemented and UI tests for all fragments.
Updating the JSON schema to the latest version (2020-12) and updating the tools which uses JSON schema to generate forms and validate form data to get compatible with the updated JSON schema.
Two main features are now being discussed to be added to Shaka-Streamer, the first is Adding option for multiple inputs which basically allows the user to flag that the input given in the input_config.yaml file is of multi input type thus Shaka-Streamer should concatenate the multiple inputs one after the other producing one DASH/HLS file that plays the concatenated output stream, the second feature is to bundle copies of FFmpeg and Shaka-Packager with Shaka-Streamer so not to bother the end user with downloading multiple binaries (and sometimes compile them) to get their stream running.
This project aims at improving the Tag/Topic system at Publiclab.org by fixing some known bugs and implementing various features like Topic Tree, Clarifying Power tag and General Tag View, Tag locking, some UI improvements in Tag/Topics display in sidebar deleting tags added by banned users etc.
The Page Forms extension provides a spreadsheet-style editing display in two places: In the page Special Pages: MultiPageEdit. Using this user can edit multiple pages that are using a particular template in a spreadsheet type display making it easier to use. In regular forms, with the form definition setting "display=spreadsheet". Using this user can edit the multiple instances of the same template within the same page in a spreadsheet-style display. Currently, the spreadsheet-style display uses the jExcel JavaScript library, jExcel provides a number of helpful input types (dropdown, date, etc.) but it does not by default allow for auto-completion using an arbitrary list of values. This task will be achieved using MediaWiki's own OOUI library.
There are several filters in PCL which have similar logic. But since they were implemented by different developers, there are code pieces with similar logic implemented across the filter module. It makes further improving the code by bringing new features that can be applied to multiple classes difficult, since one has to change all the equivalent code in different classes. Therefore the goal of this project is to remove redundancy by refactoring similar code pieces in different classes to use the same interface. It can make debugging easier, fewer changes for future improvement, and improve code readability.
This project aims to add a new debug backend to the editor, compliant with the DAP specification by Microsoft. This allows for more integrated development environments for people who use external text editor/IDEs to develop Godot projects.
TARDIS logs the simulation data generated using montecarlo_logger.py module. But it could be further improved by having user-specific capabilities as well as having a newer logging feature that can allow for the logging of packet specific properties. Through this project, I wish to add the proposed functionality to the mentioned module & increase the logging potential for TARDIS.
Gesture recognition becomes popular in recent years since it can play an essential role in non-verbal communication, emotion analysis as well as human-computer interaction. The research task is to detect hand gestures in raw news videos which are streams of RGB images. I propose a Transformer and keypoints-based pose tracking system and a Transformer and keypoints-based gesture detector to fulfill this task. This structure is composed of a keypoints extractor, a person tracker, and a gesture detector. The mission has three main parts, the first part is to track people in temporal space. In the second part, for each person, we use their hand keypoints features in temporal space to construct several keypoints sequences. The third part is to use these sequences to make predictions of the existence of gestures. I believe that for gesture detection tasks, both spatial and temporal information is important. So that is why we use the Transformer which can take into account the local information of hand keypoints in one frame to capture the shape information and it values also the relationship of keypoints in different frames that is the global information refer to the motion.
The main topic can be divided into two parts:
+Body and hand detection: I apply the lightweight Openpose model, MediaPipe library, and the optical flow algorithm. The combination can process in real-time and with a lightweight model, so it is suitable for edge devices.
+Gesture recognition: There are two main approaches for this problem: image-appearance-based models and pose-based models. These two are different in types of input data. The first approach's input is only images, while the second one's input is extracted poses from photos.
+Extension: Currently, the robot can only learn the gesture from the predefined patterns, which appear in the training data. However, the training dataset is not always available for all motions. Therefore, by applying some unsupervised techniques, the robot can recognize some gestures without any supervised dataset.
In this project: Four components will be published: BodyHandJointsDetector, ImageBaseGesture-Recognition, PoseBasedGestureRecognition, and UnsupervisedGestureRecognition. I will also code the testing client for each approach.
Project's goal is to enhance syzkaller support for FreeBSD. The project involves adding syscalls and ioctl calls to improve coverage, testing syzkaller with other filesystems, supporting fuzzing of FreeBSD's Linux system call compatibility layer, USB targeted fuzzing, and patching syzkaller reported bugs found in the process.
The Probe Desktop is free and Open Source Software that aims to provide insights on and expose the Internet censorship and other forms of network interference. Being open source, it is expected that contributions will be made by the existing community members as well as new people. These contributions can lead to breaking changes if merged unchecked.
As of now, the only way to check if an open PR doesn’t lead to more issues than it solves is manual checking. Not only is this time-consuming and tedious, it is also not enough. Writing a comprehensive suite of tests which includes unit tests, integration tests as well as end-to-end tests can help mitigate a major chunk of these challenges. These tests can then be automated whenever, say, a PR is opened to make sure the proposed changes are non-breaking.
This project aims to add a feature of native Achievements in Kodi's RetroPlayer using Kodi's UI system. After addition of this feature, users can view their achievements while playing any game. Since in last year GSoC, a way was added in Kodi for the user to login to their RetroAchivements account, so I will use it and fetch achievements data from RetroAchivements. One more point would be to show achievements only to those users are are interested in it means we will add it as an option, those who will be interested can enable achievements.
Through this project, now the user can collaboratively draft a note in real-time.
The convergence is assessed by calculating norm of the residual vector and currently the residual vector has many terms with different physical dimensions. Comparing different physical dimensions with each other does not seem to be a good idea.
So the main idea of the project is to categorize various equations and variables on the basis of their physical dimensions and calculate the residual norms for each of the physical dimensions separately.
Finally the convergence test will be modified.
This project's objective is to provide an additional backend for the visualization of two-dimensional data (channels x time) based on PyQt. It is supposed to offer high performance for visualizing data and thus facilitating signal inspection.
First of all the most suitable PyQt-based backend will be determined regarding performance and compatibility under the specific conditions of MNE-Python. The chosen backend will then be used to create an implementation with equivalent features to the original matplotlib-version. Finally the foundation for an integration of the new implementation alongside the original will be laid.
The color interface in App Inventor deals with multiple different formats, this leads to confusion for the user while switching from one part of App Inventor to the other. This project will make additions to GUI Color Picker in designer, the blocks in the color drawer, add a mechanism to detect blocks that return a color, and add an option to see the visual representation of a color in the Blocks editor. Our objective is to make a user interface for colors that solve the problems expressed by the community, one that allows the community to interact with the colors in app inventor in a more efficient, consistent, and beginner-friendly way.
This project aims to implement "Simple Feature Access" OGC Standards in Pharo. We want to be able to load classical geospatial data files like GeoJSON, to visualise in a Pharo interface and to support basic geometry operations, the same way we can perform it on OpenStreetMaps web application for instance.
I will be working on a couple of UI components for FURY’s UI module. These 2D and 3D components will be sci-fi like as seen in this scene from the movie “Guardians of The Galaxy”.
My main objective would be to develop these UI components with their respective test and tutorials such that it adds on to the UI module of FURY and doesn’t hinder existing functionalities/performance.
TACO or Tensor Algebra Compiler is a C++ library that generates efficient code for tensor algebra kernels. It also has a Python binding around it called Pytaco that makes TACO available in Python. However, Pytaco is not ndarray compatible yet. This projects intends to wrap up Pytaco along with PyData/Sparse in an ndarray compatible API. The new API will be called ndsparse. Ndsparse will eventually replace scipy.sparse as the de-facto sparse array implementation in the PyData ecosystem.
During the course of the project our primary focus will be on two widespread types of Tibetan calendar calculations, Phugpa and Tsurphu.
The aim of this project is to generalize, and make available a PyPy distributable Python package the core functionality currently within the Augur contributor worker, and envisioned as the next phase of the Augur contributor worker.The main goal of this project is Automatically identify Contributor Aliases (emails, platform user accounts) to Increase Parsimony of Statistics and Metrics With Privacy Enhancement I would be focusing on the Augur and developing useful risk-prediction analysis tools and visualization modules. The main work in this project are as follows: Construct an API Accessible Graph Database for identifying and mapping contributors who use multiple email addresses within a platform, and identifiers across platforms. Implement methods to manage this information. Integrate this information into clearer, more parsimonious CHAOSS metrics. Automate the management of contributor changes over time Enable analysis at the project level that obscures or anonymizes individual developer identity
Currently, cloudstack does not have an option for the user to clone a VM. In order to achieve a full clone, we have to manually handle it by using snapshots, new disk and then new attachment. The manual way of creating a VM causes extra overhead for the user like the temporary snapshots should also be manually cleaned up after the steps. This may influence the reliability of the system since issues may increase for a missing step. This proposal aims to integrate all these steps into one API and one UI interface and the whole project focus consists of mainly three parts:
Density functional theory (DFT) is a key driving force in modern quantum chemistry, with applications ranging from materials science to drug discovery. From a numerics perspective it amounts to solving a coupled system of non-linear partial differential equations. This is the setting of the density functional toolkit DFTK.jl, a Julia package for solving DFT problems.
Can we make a full DFT solver differentiable via automatic differentiation (AD)? There are at least three reasons why this is an interesting problem:
NetworkX is a Python library used for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks.
One very interesting field of networks is community detection, that is to group different nodes together based on similar characteristics or the number of edges between inner and outer nodes. Networkx has already implemented a few algorithms that perform community detection, but currently there is no implementation for the Louvain Community Detection algorithm which is a very efficient greedy algorithm for community detection.
The goal of the project is to implement Louvain Algorithm into NetworkX by the end of summer.
My project mainly deals with all the small but essential enhancements which are stated in the GitHub issues section. These are what I have experienced as well.
The issue is that a lot of the vulnerability testing modules have not been updated for a long time and have stopped working. The project has become unstable due to the lesser number of contributions.
Hence, I want to help stabilize the project and add a few much-needed features.
In order to achieve the same, I would be working on:
This is a project that develops a simulator consisting of an executor model abstracted based on statistics and a scheduler model that are executed like actual running with manually managed timeline. Directly, this project can increase the reliability of nemo. Indirectly it can contribute to speed up future projects and be a springboard to future projects.
Many system call decoders in strace are very similar in structure. This proposal aims to incorporate a system for generating syscall decoders from a system call description language into strace’s build system. This project would allow the strace project to leverage descriptions of a large number of system calls and ioctls that are already described in a similar format.
Banzai Logging Operator allows users to build complex logging pipelines by writing Kubernetes custom resource configurations. But it could be a tedious task to properly understand how these log pipelines work when we have 100s of services spitting 1000s of log records at once.
The goal of this is to create a tool that would capture a log stream from a running pod and let the users replay it as they desire while correlating those logs with Flow resource specs and highlighting the applied filters so that users can easily understand how the Logging Operator interacts with their application and fine-tune it to their liking.
This proposal aims to bring a selection of much needed improvements to the knife tool in Blender which will better the modelling workflow of the tool. It proposes such changes as the ability to undo individual steps of the cutting process, a visual measure of distance and angles per cut, more precise angle control in constrained angle mode, the ability to snap cuts to global or local orientation, knife usage in multi-object edit mode and an edge removal mode.
MinPlatform is vendor-agnostic but its primary usage, thus far, has been for UEFI system firmware for real motherboards. And till date, the only motherboards supported use Intel Processors. This makes it difficult for new developers to get started, as it can be difficult and costly to find and purchase the exact motherboard that a given MinPlatform board port was designed for.
This project aims to solve this problem by creating a MinPlatform board port for Qemu. This would allow developers to run MinPlatform on top of Qemu without the need to find and buy an exact motherboard. We thus have to create a QemuOpenBoardPkg. We would also need to improve on the dummy FSP for Qemu. This currently has only the API mode implemented, so we want to implement the dispatch mode and integrate it to the QemuOpenBoardPkg to make it a complete test vehicle to create a fully open-source example of FSP including both API mode and Dispatch mode.
HAPI resources are like conventional data classes that can be serialized into JSON/XML. FHIR proto buffs on the other hand are classes that are used to create the protocol buffers for the FHIR resource they represent.
This project is aimed at creating a library that will convert HAPI structs (which use JSON or XML data) to FHIR protos which use Protocol Buffers. This would enhance healthcare data exchange due to the better performance of protocol buffers. It would also allow HAPI commands to run on data stored in FHIR protos. Sample code that would demonstrate the use of this library to execute Clinical Quality Language Using HAPI against FHIR protos will also be included.
Behavior Metrics comprises a wide range of robots with the pipeline completely set for various Deep Learning and Reinforcement Learning (RL) setups. With its main concern over the racing track, the Formula 1 (F1) setting solves the line following objective well. However, the presence of 2 separate pipelines for RL and DL is confusing to the users. The DL base works on the JDERobot app, while the RL base takes the privilege of gym-gazebo. These two bases are unable to communicate with each other. Also, the current framework does not leverage the full capabilities of testing scenarios and robots. Apart from line-following, F1 racing for autonomous maneuvers and drone racing has gained much popularity. Although these settings are highly derivative, it requires few significant changes in the control architecture and modularity wrt multiple robot settings. This project’s primary goal is to move towards more extensive support and documentation of Behavior Studio to suit the same RL environment or DL brain to multiple robots with continuous control integration. The advantages of such changes will make the framework more user-friendly and adaptive to various tasks and robot settings.
In this proposal, I mainly focus on two dimensions provided by Quark-Engine, including resilience and performance. According to the mentor, there are some critical issues needed to solve below.
For maintainability, it is necessary to deprecate Androguard, which is not a maintained library anymore, for Quark-Engine. Radare2 is an alternative tool recommended by the mentor and can replace all the functions of Androguard. The proposal aims at continuously improving the new core library until it is reliable enough to be used in Quark-Engine.
Quark-Engine consumes many resources when analyzing a big file due to the core library and the sequential computation. We found that replacing Androguard can solve the former issue. And introducing parallel computing solves the latter, too. As a result, I plan to make Quark-Engine parallel with the following improvement strategy.
The project proposes to revamp the existing mlpack bindings. Mlpack is one of the most flexible machine learning libraries when accessed through C++ but when it comes to the interface in different languages mlpack still has some ground to cover. This is not intentional, rather it shows how much mlpack has grown over the years. Initially, mlpack only had a command-line interface for which it was obvious to provide as much functionality as possible inside a single function. Now that mlpack not only provides a command-line interface but also an interface in Python, Julia, GO, and R, it has become a necessity to remove the single function interface and use a more modern interface with which the user is more familiar.
AnalySim is a data sharing platform similar to GitHub, but specialized for scientific projects. It seeks to simplify the analysis and visualization of datasets. AnalySim is designed to promote collaborations and to improve existing datasets through features like forking or cloning, features specialized to allow users to start new projects, collaborations or join existing teams or projects.
First feature I would like to add to AnalySim is forking projects, which will help collaboration between researchers. One can fork someone else’s project and improve upon it by adding more data or improving analysis. Second feature I'm interested in is adding a new design template. Finally, I want to improve the existing documentation. If there's extra time, I would like to work on adding a component that allows for CSV file viewing.
This project offers me a great opportunity to practice my technical skills of programming the web based technologies I learned in my classes. Specifically, I have experience in working with Angular, web development and web design. I aim at starting a career in software development where I want to put to practice the skills learned during this project.
Mitmproxy provides a lot of features for debugging, testing, and penetration testing. Mitmproxy is already a really awesome tool at this moment, but I have a plan to improve mitmproxy even more.
Specifically, I’d like to make mitmweb’s UI rich and easy to use.
1, When we want to intercept a flow and forward it in mitmweb, we have to select the intercepted flow in the flow view and push the resume button. If we implement one click resume / accept all button, we just have to push one time to forward intercepted flows.
2, We can edit the headers and contents in HTTP request in mitmweb, but we currently can’t craft HTTP request manually. I’m going to implement a raw editing mode for Request viewer.
3, We can make a target scope for interception in regular expression, but we have to write it in one liner. If we can make several target scopes and display them in a different view as “target view”, we can easily manage each target scope. In the view, we can turn on and off each target scope with a button.
4, A feature that we can add a url of a selected flow to target scope for interception from a dropdown menu in the upper navigation bar
5, A terminal that we can use mitmproxy commands
Users configuring their Envoy-based data planes don't know how to find the optimal Envoy configuration given their workload's resiliency and performance requirements. Nighthawk, Envoy's load generator, supports adaptive load control and horizontally distributed scaling of itself. Using distributed load testing and the creation of a set of adaptive load controllers, Envoy users can be empowered with repeatable tooling to automate identification of an optimal Envoy data plane configuration.
“p5.js 2021 Showcase: The Love Ethic” is a proposal for the continued development of the p5.js showcase, but with a particular focus on the softness of the programming language and its ability to be a radical community with values rooted in social justice and accessibility.
This showcase will, as said so beautifully by @sailorhj, “put the soft in software” and be heavily influenced on bell hooks’ writing philosophy of living by the “love ethic.” This will be implemented through the design, tone, and process of curation for the showcase.
The PSLab project has many instruments and supports some external sensors, but there are many sensors which are supported by pslab board yet to be implemented. Since Adafruit maintains a large repository of sensor drivers, we can make use of it by writing a compatibility layer between busio and pslab-python. In this project, I will refactor pslab-python’s serial bus modules and add busio wrapper which uses pslab-python’s modules internally.
Implement various animal interaction improvements in the Josharia's survival gameplay. Currently, the only way to obtain wool in-game is by killing a sheep. A Sheep shearing mechanism will help the player obtain the wool item in-game. Apart from this various interaction elements such as flocking and luring animals will be introduced. These improvements are suppossed to aid the player in the survival aspect of the game. Currently, animal spawning only works upon chunk loading. This will be improved by creating a new spawning mechanism for animals which will allow spawning during runtime of the game. These improvements will benefit all gameplay modes in Terasology.
While the current testing suite of KIO FUSE tests individual operations pretty aptly, it lacks the support to put KIO FUSE through regression tests. KIO FUSE has never been through regression tests and chances are, doing so would uncover bugs that went undetected until now. KIO FUSE is updated fairly frequently and new features are still being added, making regression testing even more necessary to prevent new bugs from creeping in.
The lack of regression tests in KIO FUSE's current testing suite can be fixed by integrating xfstests with it. Xfstests is considered as the quintessential filesystem regression testing suite and KIO FUSE would benefit greatly from it. A more rigorous testing regime would translate to an even more robust and reliable filesystem. Testing KIO FUSE would mean we're testing KIO slaves as well. Thus, the project benefits KIO to a large extent. As of now, xfstests doesn't support FUSE, and that'll have to be added as a part of this project. FUSE support for xfstests would be a major plus since it'd allow hundreds of filesystems written using FUSE to be tested.
The project not only benefits KIO, KIO FUSE and KDE, but FOSS community as a whole.
High speed content delivery from a messaging app to a Wagtail site.
AutSPACEs is a citizen science platform that aims to understand how sensory processing differences affect autistic people all around the world. It captures an autistic user's experiences with sensory processing challenges and generates a qualitative dataset. This data serves two main purposes:
This project aims to build and implement a working prototype of the website in collaboration with the autistic community. The potential approach to this project would be the following:
Currently, SMI doesn’t provide connectivity over multiple Kubernetes clusters. It is becoming common for users of a service mesh to have more than one cluster.
What if Service Meshes could be connected with associated features like observability, control, and security, etc. even when they are being managed under different organizations.
This project focuses to provide the ability to discover traffic across different service meshes and authenticate it, where each mesh is in a different and untrusted administrative domain, where each mesh can be of the same or from different vendors, can have the same or different control and data plane implementations, be single or multi-cluster, and can provide the same or different functionality to its customers.
Extending multi-cluster capabilities mainly depends on two core features, which are required to provide the ability to discover traffic across different service meshes and authenticate it.
Jailhouse is a static partitioning hypervisor and its support for Automotive Grade Linux is added in the recent previous seasons of this program. This project aims to implement the inter-cell communication between Jailhouse cells with the help of VirtIO block. The whole project is divided into two parts, first one will focus on implementing a basic working with plain Linux as a non-root guest cell and in the second part, everything will shift towards RTOS as a non-root guest cell.
Minimalist 3D scan (taking multiple pictures, recording camera position, using opendrone map to rebuild the 3D scene) with the house faces (accessible/visible faces) then load it as georeferenced data with the database and being able to export the data back on MapMint for 3D viewing.
The main goal of my project is to implement incremental improvements to Debian’s CI platform which is a crucial part of Debian’s infrastructure and making the platform easier to use and maintain.
This proposal aims to solve various bugs and bad UX related to file transfer.
In this project, we aim to extend the existing collection of the Brain Dynamics toolbox for MATLAB and add more models to the bdtoolbox. The goal is to simulate a set of dynamical systems models from various fields showing various phenomena like the bifurcation phenomena and various system responses. These models will hopefully be able to reduce the implementation burden on the students and researchers and serve as an insightful platform for modelling of the dynamical systems.
Ganga is a tool to run data analysis jobs along with managing associated data files easier. Ganga also allows for submission, bookkeeping,specification, and post processing in computational task management. In today's world where computation and bookkeeping is a monumental task, the requirement for a task-management tool is important. Ganga GUI comes into picture in this field with added resources of Ganga as well as the ease to use it with the help of its GUI. Improvement in the functionality as well as improvements in the visual aspects of GUI are important. This will improve adaptability, reliability and ease to use. The GUI will also help the community by attracting new users, because of the easy to use GUI interface.
An easy to demo apk is to be made with latest features of Android Fhir SDK.
Competing Destination (CD) models, which are an extension of Spatial Interaction (SI) models, has been around since 1980's and are often used within Economic and Social Sciences . CD models involve the analysis of flows from an origin to a destination similarly to traditional SI models, however, CD includes the ‘Competing Destination’ term also known as ‘Accessibility’ term, which accounts for the spatial-structure effect of the flows from behavioural perspective. Although the SI models are established within Python and R modules already (SpInt, simR), specification for deriving Accessibility term for CD estimation is missing. This project aims to fill this gap by developing a Competing Destination class that will include the computation of the accessibility term and will be binded to the existing SpInt module. The main challenge here is the scaling of the accessibility computation for large datasets. This is an important aspect of the project as flow datasets often have hundred thousands and even millions records. This project will extend the use of the SpInt module and PySAL library for high level analysis of spatial flows.
This project aims to add support for arrays and allocatables in LFortran. Specifically, features to be added for arrays are as follows,
For supporting allocatables, the main focus would be on generating instructions to allocate memory in heap using malloc. There are some miscellaneous goals as well, such as improving support for pointers and kinds and some bug fixes discovered along the way.
This project is aimed at developing a software package to identify various dependencies for Open Source Software, using some of the existing tools to analyse dependencies. This projects deals with code level dependencies (direct and transitive) and not infrastructure based dependency like OS or database. This project would be implemented using augur which is a software suite for collecting and measuring structured data about free and open source software (FOSS) communities.
The Alliance of Genome Resources is a consortium of 6 model organism databases (MODs) and the Gene Ontology (GO) Consortium whose goal is to provide an integrated view of their data to all biologists, clinicians and other interested parties. Alliance of Genomic Resources now has several services which require authentication and authorization. The aim of this project is to implement a single service to maintain authentication and authorization across the project as the number of services increase.
This authentication and authorization service will allow users to sign in using Oauth2 (Google, Microsoft, etc...). For the Alliance members, JWT access tokens and refresh tokens with specific user information will be generated, which could be used for authentication of Literature service at this time and other services in the future (File Management System(FMS), Public Website, Annotation Database, Curation Interface).
The implementation of this project consists three parts: Authentication and authorization backend service for Alliance members, User Login for non-Alliance members and A Frontend interface for user login and shows user statistics.
The statistical inference of properties of astronomical objects can be done using parametric modelling of Fourier products and light curves including common algorithms for time series. Introduction of current state-of-the-art methods for stochastic systems using automatic differentiation, variational inference can make the analysis of periodograms efficient and robust. In regard to (https://github.com/StingraySoftware/stingray/issues), the first goal of this project is to add automatic differentiation and modern optimization algorithms to increase the robustness of the existing infrastructure. The second goal is to extend the existing infrastructure to facilitate building fully probabilistic models using PyMC3/Tensorflow packages.
This GSoC project proposes to create the UI side of a network-based hierarchical viewer to visualize gene annotation at various levels of systems organization, including: gene-gene interactions, cell type, disease, and known drug targets.
AGM (Active Grammar-based Modeling) is a Project with the objective of proposing a detailed description of how the software modules of the robots can interact with each other, and a world model structure. AGM was designed on Python2, and now Robolab, the organization to which I am proposing this project, wants to port it to Python 3. These would be the main objective of this project, to port AGM from Python 2 to Python 3.
This objective requires two very different parts:
The first part is the port from Python 2 to Python 3 in itself. This means the changing of the code to adapt AGM to the new version of Python. However, this alone is not enough.
The second part is testing. Tests are required to check if the program is working as it is supposed to work. On programs like these, it is very important to run tests to assure that each part is ported correctly. If tests are not run, there is a risk that certain parts of the code not commonly used do not work correctly or return errors. In short, the objective of this part of the project is to effectively test the program to assure that the port is working correctly. Coverage is a part of this process too, so we also need to do it.
This project aims to fix the issues regarding the Android platform that includes fixing the shaders, the audio system, and the addition of touch and tilt features for a smooth gaming experience on Android Devices.
The Node Disk Manager (NDM) daemonset runs on every node in the Kubernetes cluster, discovers and monitors various storage devices connected to the node. It exports these devices as BlockDevice (BD) custom resources on the Kubernetes cluster, which are then used by other OpenEBS stack components. The NDM currently supports the detection of various storage devices connected to the node. However, it cannot detect specific changes that may happen to the block devices while connected to the node. Specifically, the NDM cannot detect changes in the mount-point(s) and the filesystem associated with a device. It also cannot detect a change in the capacity of the block device.
The mount-point(s) of a block device can easily be changed on a system. It is easy to change the disk size on the cloud too. This causes issues in the Kubernetes cluster using OpenEBS as the changes in the device properties will not be reflected immediately in the BD resource.
This proposal aims to solve the issue above by adding functionality in the NDM to detect changes in the mount-points and capacity of supported block devices and propagate them immediately to the corresponding BD resource.
The main aim of this project is to implement Joints Method in Sympy under mechanics in physics module as it would open up the use of the library to a much wider set of users because they will be able to construct dynamic models with less knowledge of underlying mathematics. Currently to solve kinematical differential equations, users need to define those equations and solve them using Kane’s or Lagrange’s method. With the help of JointsMethod, users would just need to define the system with joints and bodies and JointsMethod would form and solve kinematic differential equations all by itself , without the user doing any mathematics.
This project aims to design and integrate the integer “Multiplication and Division Unit (MDU)” with SERV core as a co-processor. The MDU will support all of the instructions that are provided in “‘The RISC-V Instruction Set Manual. Volume I: Unprivileged ISA’ chapter 7, M-Standard Extension for Integer Multiplication and Division, Version 2.0”. This MDU is to be designed in a way that it would use most of the DSP resources on the targeted FPGA board and it would be generic and parameterize so that it can easily be integrated with any of the RISC-V core.
This Project aims to help the developers in the Oppia Android team build features, solve issues and commit them into the develop branch without affecting the releasable code. In other words, with the help of these parameters, developers will be able to keep their code up-to-date with the develop branch even if the feature that they are working on isn't completed yet and shouldn't get merged into the release-ready code. These parameters will also help us have more granular control over different parts of the codebase. We will have a medium to tweak the App behaviour remotely without the need for a new release.
This project is about adding optimised and accurate high-order interpolators to the LHAPDF C++ library. This is required for adding support for Chebyshev polynomials, which are a very efficient way to parametrise Parton Density functions. Parametrising PDFs is essential to studying the high energy collision experiments that happen between protons in the LHC, as they encode details on the internal structure of a proton.
The goal of this project is to develop a facility location modeling module that supports various distance measures and returns an optimal solution to the problem. The example provided will serve as a base for this project. This module proposed will support four models:
Exporting chats is an easy way to save conversations into the disk, which can be archived or shared with outsiders. This feature will be handy for users who have millions of messages and can’t easily access the oldest parts of their messaging history. As Matrix also provides end-to-end encryption via the Olm and Megolm cryptographic ratchets, the process will include decryption of messages. I will be using matrix-react-sdk and matrix-js-sdk, which provide adequate functions and methods to communicate with the server, handle encryption and build a very feature-rich export tool.
The proposal focuses on Writing vulnerability rules and gives insight into writing Semgrep instances of the present analyzers available with Gitlab.
Colour is an open-source python package providing a comprehensive number of algorithms and datasets for colour-science. It also has support for different colour models, allowing easy conversion from one colourspace to another. A colour model is a way to define colour. It describes how a colour will appear on a computer screen or paper. I plan to work on improving this feature by implementing new colour models that are required and at the same time improving the existing ones.
I have started doing the initial work on the EOS Adobe XD plugin and I found the community extremely supportive. For the summer, my goal would be to increase the capabilities of the Adobe XD plugin, and develop the Angular package for EOS. This might touch the sister packages for React library and the original NPM package and I would ensure there are no frictions during development and we are on the same page while moving forward.
Toil is an open-source Python workflow engine that lets people write data analysis pipelines in Python, CWL, and WDL. Toil has support for common workflow language (CWL), an open standard for describing analysis workflows. The power of Toil was demonstrated in “Toil enables reproducible, open source, big biomedical data analyses” paper published in Nature Biotechnology volume where it is described how well it scaled for a dataset of 108 terabytes on 32,000 cores on a public cloud.
This project aims to implement data streaming to speed up the analysis by avoiding slow disk/storage IO and speeding up the start of tool execution when it isn't required to wait for data to download. The main focus is to implement this first in AWS S3.
WebAssembly is an emerging standard for a binary instruction format designed to be run on a virtual machine. It is designed to be portable, stable and fast.
It is already possible to compile to WebAssembly from many different programming languages, including ones that are currently unsupported by MetaCall (e.g. Go, Zig, Kotlin and Swift). This project will add support for a wide - and expanding - range of programming languages through the implementation of a WebAssembly loader.
Inkscape has widespread GUI integration. Often the same function is called needlessly multiple times. The biggest problem is that most Verbs require a desktop . This means that they cannot be used in a headless Inkscape.
Gio::Actions are defined independent of the GUI (unlike GtkAction), they can be used by "actionable widgets" (menus, buttons, etc.) by simply referring to them by name. They can also be remotely activated by D-Bus and GNotifications.Gio::Actions will allow a future GUI-free Inkscape version . Actions are purely functional. It provides a uniform interface for calling functions with an optional single parameter that is not tied to the GUI. Redundancy in the code for signal passing will be reduced and results in an easier to maintain Inkscape with more flexible GUI .
Command Palette overall lacks specificity while taking inputs. It would be nice if a more specific hint is given to the user about the input in Placeholder text similar to Visual Studio Code. Example - Open command Palette > Rotate > 30 ( placeholder = "Enter a double ..." [ present ] to “Give a real number as input for angle” [ after ] ) .
Add a config and the ability to use balanced reads when RGW sends a RADOS op
Search is a fundamental operation performed by Kiwix that helps users to find the content they want in a quick and efficient manner. Though it is highly functional right now with many more enhancements coming in libzim7, there are still some missing features and room for improvement. Namely:
The project aims to address these issues such that kiwix users can have an overall improved search experience.
This work aims to add Loop Closure Algorithm based on HF-Net+BoW into the OpenCV RGBD module. HF-Net can extract the local and global features at the single inference. To ensure the Loop Closure Algorithm entire pipeline has good precision, the loop closure module will use local and global features at the same time. The main scheme refers to DXSLAM , which is superior to ORB_SLAM2 in many aspects.
Creation of a Knowledge base completion Plugin for Wikibase/Wikidata and a badge service for Wikibase/Wikidata
Gaussian processes (GPs) are flexible probabilistic models with a wide a variety of applications. However, in their simplest form they scale notoriously poorly with large datasets. There has been much work in recent years to develop approximate methods which enable GPs to be used with much larger datasets.
This project will focus on implementing such approximate methods for Gaussian processes within the JuliaGaussianProcesses ecosystem with the goal of achieving performance which is competitive with similar established Python packages (specifically GPFlow and GPyTorch).
The current version of Pocket Code doesn't have support for particle physics. This project proposes to implement and integrate a particle system that would allow the addition of smoke, fire, and other such particle effects in the games! The visibility, position, type, velocity, color, and other such properties of the particles could be controlled using the new "particles" bricks that will be added as part of the project! This will enable effects like a glowing effect around coins and collectibles, glowing trail behind fast-moving objects like a ball or a meteorite, flames, smoke, explosions, etc. giving much greater freedom and control to users and allows them to let their creative juices flowing!
Since the migration to Android Architecture Components has already started, this project aims to integrate Room instead of SQLiteDatabase as a better approach for data persistence. This idea involves the following challenges:
The sigrok project is a signal analysis software suite which supports various measurement devices such as oscilloscopes, logic analyzers, multimeters, etc. Since PSLab provides several such instruments, we plan to add it as a mixed signal device to libsigrok.
The Internet Key Exchange Protocol Version 2 can use arbitrary signature algorithms for authentication as described in RFC-7427. Currently, Libreswan supports RSA, RSA-PSS, and ECDSA. This project aims to add support for EdDSA as per RFC-8420.
The project aims to Create and Enhance APIs and to produce a well built backend mechanism related to an Education Platform which strives to enable 100% education and will help in upskilling developing countries and rural areas. The APIS to be created are Doubt Forum API, Scoring API ,Contest API and Assignments API These APIs would be used by the client side of the app to fetch data and render quality functionality
The library shapeless is found everywhere in the Scala ecosystem, helping people do metaprogramming and typeclass derivation without using macros directly, which would otherwise be required. A new version of the Scala language, Scala 3, is removing macros in their old form, but also providing new tools for typeclass derivation and meta programming. A new version of shapeless exists for Scala 3, but porting code written for shapeless 2 is not trivial.
The goal of this project is to cross compile the old version of shapeless to Scala 3, in such a way that end users do not have to change anything about their code for it to continue to work. I will focus primarily on the core metaprogramming features shapeless provides. I will tackle lesser used features if it is feasible to support them, and as long as there is enough time to not impede on the major features.
This will hugely benefit a large portion of the Scala community because of how many things depend on Shapeless. If Shapeless 2 does not exist on Scala 3, it will mean that many projects will wait much longer to update to Scala 3, and a lot of new code has to be written to support Scala 3, both in applications and libraries.
The project aims at creating and deploying a user friendly, interactive and accessible website for PEcAN Project. The following objectives will be accomplished after the successful completion of the project. Revamping the design of the PEcAN Project’s website and drawing wireframes(using Figma). Based on Developing a SPA(Single Page Application) website using NextJs. Markdown Documentations will be integrated as web pages. Functionality for adding and editing documentation/markdown. Setup Github actions for continuous integration. Write detailed documentation for users and developers
After accomplishing above tasks we would have a feature-rich, accessible website with a clean and elegant UI.
The project is aimed at creating few samples to demonstrate capability of OpenCV 3D module. After that all useful methods will be collected for a substitute library for VTK which will provide needed framework for the current opencv_vis module. This new library should be lightweight, easily expandable and should satisfy all OpenCV requirements, for example, cross-platform capabilities.
The design tooling consists of a small set of applications that boosts the design team and developers productivity. App Icon Preview, Symbolic Preview & Icon Library shares more or less a common base code for parsing SVG files, rendering icons and other stuff. The project will consist of porting App Icon Preview and Symbolic Preview to GTK 4 while moving parts of it's code to a common library that will be shared between the there utilities.
I am a recently graduated teacher in, amongst other things, computer science. I have been working with visual programming languages for several years, both creating programs and teaching to others. In my Google Summer of Code I want to dig deeper in connecting visual programming of embroidery patterns with electronics, like e.g. LEDs and therefore bring sparkle into embroidery!
A honeypot for IOT/OT protocols with a dynamic response system that records the attack data. A tool which can help securing IOT/OT infrastructure and collects data about the attack which can be used for early detection in Intrusion Detection System(IDS).
I propose creating a plugin for Joplin, which allows notes in a notebook to be organized in a kanban board. The board itself is a special type of note, which, when opened will show the kanban interface in a new panel. On the board each item is a note and each column is a tag or some other property of the notes. Dragging notes between columns updates their properties automatically. On mobile and on clients which don't have the plugin installed, the board note simply shows as a static markdown table, so that tasks can still be viewed.
This proposal draws from the discussion in this GitHub issue and this forum thread, especially uxamanda 's designs and ideas. Big thanks!
This project aims to develop an audio output protocol (UEFI_AUDIO_OUTPUT_PROTOCOL) that will allow UEFI applications and drivers to communicate with audio devices. In particular, this project aims to make the protocol compatible with the VirtIO sound specification.
git cat-file has options --batch[=<format>] and --batch-check[=<format>] that can take a <format>. It would be nice if the implementation of this <format> would use the as much as possible the same code and syntax as the ref-filter formats.
I propose to take up the task of integrating a tool calculating the Distortion Index statistic into the PySal library, as discussed provisionally as a project idea.
Although a final year undergraduate student, I have been highly commended for recent work within the field of analysing segregation using multi-scalar metrics. I believe this has come as a result of my passion for the field, and hope to develop my passion and skillset further through undertaking this project.
The areas proposed for development within the discussion of the integration of this statistic are clearly structured and I hope this will help an early-career researcher like myself to utilise my existing training and further advance my understanding, with the support of PySal's mentors.
The project aim is to create an Extension that will synchronize CiviCRM with an instance of the open source peer-to-peer texting platform/project, Spoke.
Integration of the meta-ros layer with Automotive Grade Linux (AGL), to support Robot Operating System (ROS2) which is an open-source robotics middleware suite. Correspondingly develop an application using ROS2 on AGL to visualize LIDAR sensor data streams to accurately map 2D depth points with the surrounding environment. This project would benefit the Automotive Grade Linux (AGL) platform by making the AGL platform development ready for Advanced Driver Assistance Systems (ADAS) and Autonomous Driving systems using the powerful Robot Operating System (ROS) framework.
The goal of this proposal is to refactor DeltaCode to use Scancode-Toolkit’s Virtual Codebase class. This refactoring will allow DeltaCode to be a library as opposed to only be used as a CLI tool, moreover, this refactor will allow DeltaCode to determine deltas much more effectively in the form of BFS scan of the two tree structures unlike indexing the entire codebase.
I would like to implement the undo function into libged. This will be a significant feature addition to BRL-CAD, giving designers the option to revert any mistakes they have made. I would also like to implement the transaction based command system. This will help in avoiding corruption of files even if the process is interrupted by a keyboard interrupt or power failure midway through changes.
A onestop iOS application for exploring monuments all around the globe!
The Rocket.Chat Poll App is the go-to app for teams and channel members of any Rocket.Chat rooms for a rich interactive poll. It currently offers multi-voting and single-voting controls with confidential and open responses. The results are displayed in the form of a bar graph with an option to finish the poll. In this project, I plan on adding several new features to the Rocket.Chat Poll App and improving upon the existing ones to augment the user-experience and further the user-engagement achieved through the app.
With this proposal, I intend to shed light on the various areas which can be improved to better the user experience of DefectDojo. The application currently solves a very important problem which falls under resource/project management and as it stands, management can get overwhelming at times. The user application that aims to solve this problem should be more responsive and smooth, in terms of usability, intuitiveness and the value it brings to the end user. In this proposal, I continue to explain how various screens can be made more intuitive as well as faster and more responsive through the use of modern JS libraries and frameworks which have been adopted heavily by the industry such as the React Framework. As explained further, the framework aids in preventing from reinventing the wheel and focusing on features and challenges more worthy of the development time.
The project's aim is to develop a chatbot that can help people create spec documents without knowing the specification.To get started with, the bot will consume the spec, JSON schema and serves the user as an expert. So based on a set of questions and answers it will generate an AsyncApi spec document according to the use cases. The bot will be able to build its knowledge really fast, thanks to Wit.AI NLP functionality. We also plan to build an integration functionality which will allow the bot to be available either to the CLI or UI by using the integration functionality.
The test driver (as accessed via the test:/// URI scheme) is a fake virt driver designed to let applications test against libvirt with fake data and not have any effect on the host. As can be seen from the API coverage report http://libvirt.org/hvsupport.html there are quite a few APIs not yet implemented in the test driver. Ideally the test driver would have 100% API coverage, and so the goal of the project is to address gaps in the API coverage.
So the work is trying to expand API coverage as much as possible.
CUPS-Filters provide the filters which CUPS needs to convert job data from the input data to the printer's native language. Filters enable a user to print a file even if the printer does not support the file format. Currently some filters are in the form of standalone executables. This uses a lot of CPU resources for running printer applications due to so many calls for each individual executable. So the primary focus of this project is to convert a few filters (pdftoraster, texttopdf, bannertopdf) into filter functions. These functions would be integrated in a shared library so as to reduce the number of calls to individual filter executables and minimize CPU resources exploitation.
Modernising and modularising the App Inventor Projects View by introducing shortcuts for project actions and integrating markup UI declarations with standardised design systems
The project aims to add network graph visualization support to Javis.jl. Graph visualization can be made quite simpler and elegant if it is in an animated manner. Currently, there is no such standard package available in Julia that does this. Javis supports extensive animation options on a 2D canvas, which serves as a good starting point for the implementation for such a tool.
The project will add an API to animate graph nodes and edges (as supported in LightGraphs.jl). It will also provide support for neural network model (FluxML) visualization and animations on a limited scale. Data flow visualization and animations can also be done on top of these constructed graphs.
Software Heritage has the biggest open archive of the source code publicly available, it captures software projects from various forges and all of them are stored inside a (giant) Merkle DAG. Currently Software Heritage has an experimental tool to check, from a given code base, which part of the source code is already stored inside the archive. The main idea for this proposal is to enhance the Software Heritage Code Scanner to make it usable in real production use cases and lead the scanner to be on par with the actual state of art industrial scanner tools.
Implementing API Calls to read and write BCF files which is currently done by the existing Libraries and also to create a server to do the API calls.
I propose my own project idea relating to Apache APISIX growth, titled "Redesign and develop Apache APISIX landing page". Main reasons for me to propose this project are -
Considering the above issues, it is essential that a redesign is needed to solve this, because to solve them would require addition of multiple new sections to the website. This project will result in a new website for Apache APISIX, designed by me, (Mockup in proposal) solving the above mentioned issues.
I have discussed this project idea with Zhiyuan Ju (PMC and GSoC mentor at Apache APISIX) and even had my project proposal reviewed by him with agreement on its content.
Security best practices are of utmost importance on all layers if a system is to be considered secure. Unfortunately, during my internship at ISP RAS my colleague Vitaly Cheptsov and I identified multiple defects in the current implementation of the EDK II Image Loader. In consequence, I was tasked with implementing a more robust version of the library, ensuring reliability and security using formal methods. After the internship has concluded and our Image Loader has proven to be functional in many real-world scenarios, it is time to integrate it into the EDK II core, to increase the overall level of the firmware's security. The surrounding ecosystem should follow to take full advantage of the new code, including application of stricter memory permissions.
Oppia's lessons can require between 15 minutes and an hour of time depending on a number of factors from learners: understanding of the material, literacy capabilities, and general focus. One potential behavior in the app is that we don't save the user's progress if they navigate away from an exploration (lesson) which, given how long lessons can take, is expected to be a frustrating experience. To mitigate this, we'd like to introduce support for a lightweight checkpointing system wherein users' saved state is fully retained if they navigate away from a lesson & back.
WAL-G supports two backup types: delta(incremental) and full. Delta backup has higher performance on pushing phase, but it is slower on fetch and sometimes user has to do full backup to remove a bunch of old WAL segments accumulated over time.
Nevertheless creation of full backup could take hours on large (several terabytes) databases. To deal with it file uploading time could be reduced by creation of remote copies of unchanged archives from last full backup in cloud storage instead of direct uploading.
This project proposes the implementation of an ext4 driver in Tianocore. EXT4 is widely recognized as a de-facto standard filesystem for modern Linux and Android systems, with its usage being almost ubiquitous. Therefore, it's of utmost importance to add support for it in the leading UEFI open-source implementation.
Sea Floor Sampling is a tedious job and requires a lot of manual work. This project intends to automate the process of labelling the videos using object detection and classification methods. This will reduce the amount of time taken drastically.
IOOS Data Demo Center Migration to Jupyterbook. JupyterBook is a simple yet elegant way to show the documentation of one's work. It can be used for scientific purposes as it builds publication-quality books. The aim of the project is to move the existing Demo Data Center to a jupyterbook style and automate the process.
Project Information Nomos and Monk are the two leading scanners FOSSology uses for license detection and Copyright for scanning copyright,url,emails and holders name. FOSSology approach is to detect licenses with either a large (large: 2500 regexes) dataset of regex patterns (nomos) or a full string comparison against license full texts (large: ~400 text) (monk). Atarashi license scanner implements multiple text statistics and information retrieval algorithms. ScanCode Toolkit is a very established license scanner similar to Nomos or Monk. It is a simple python based command line scanner that runs on Windows, Linux, and Mac. It implements a number of different approaches and integrates these into one application for identifying and classifying license relevant content in packages. The basic idea is to use the command line interface from the ScanCode package in order to be called right from the FOSSology application. FOSSology will pass a single file and take the result from the ScanCode command line call. Scan result will include license name, the SPDX key, Score, Copyright and Holder name, Emails and Urls present in the given code and as per requested by the user.
Precision landing has been a popular feature that has attracted many research groups and professionals worldwide. ArduPilot’s implementation has been tested in several conditions and has been proven to work. Yet, there are a few shortcomings in the codebase that have become an impediment and require improvement. Depth cameras have also proved to be extremely useful in increasing the situational awareness of the environment. Improving ArduPilot’s precision landing capabilities combined with the powers of a Depth Camera should make a robust approach to this unique problem.
The goal of this project is to make a simple and light recommendation system that helps in recommending similar circuits to the users in the most efficient way possible. From the database, the User ID, Project ID, Project description, the number of Views, and the number of stars will be extracted and saved in a CSV file which would then be loaded into the program. The description is used in clustering similar circuits together and then the views and stars (by choosing some weights) would be used to re-rank within a cluster. Feature extraction is done using the TF-IDF encoding and a text embedding is made on which a suitable clustering algorithm would be used in order to group similar circuits together and sent for re-ranking. A content boosted approach can also be used while re-ranking and using a similarity measure while displaying the circuits to users in real-time. The project later focuses on integration with the Circuit Verse website by helping with the UI of the recommendation system.
Openmined's Syft library provides an infrastructure for computing on data you do not own and cannot see. It allows data scientists to work with data owners and provide machine learning solutions while preserving the privacy of the data. Currently, its infrastructure allows users to train models using libraries like PyTorch. While Pytorch implements many deep learning models, it doesn't implement many machine learning algorithms like SVM and Random forest. This limits users of Syft in terms of using variety of algorithms to train models on remote data. Scikit-learn provides many simple and efficient tools for predictive data analysis and is very popular and is used vastly in the Data-Scientist community. This project aims to integrate Scikit-learn into Syft's infrastructure to allow users of Syft to use all end-to-end algorithms and features which Scikit-learn provides.
OrcaSounds main objective is to educate and protect the orcas in the pacific. But in order to do that the website specifically the frontend needs to be optimized to keep users on the website and to make them willing to come back. Not only that but with the rise of users who use their phones to access a website;OrcaSound needs to be mobile accessible and also comply with the a11y requirements . In order to reach a wider audience and fulfill their business goals. My project would involve using the technologies of html,css , react , react-elements and javascript in order to improve the frontend.While working with the Ux team alongside this process. I want to create an attractive landing page that captures attention, organize the footer, create a blog post gallery and optimize them for SEO.
A new quad-double type would be implemented, initially as a wrapper around the QD package's qd_real class authored by David Bailey. Tests for correctness and benchmarks will be subsequently written along with the documentation. If time permits and if the mentors find it feasible, a new multiple-double type based on the same algorithms as QD package will be written with no dependency on external libraries.
With the recent advances in the processing and analysis of texts in natural language, the conversion of texts into RDF triples is becoming a real possibility, allowing to build knowledge graphs from raw text.
In order to contribute to the open source software development for the DBpedia community I propose a project for the software development of an online tool that allows users to convert texts such as the abstract of a certain DBpedia resource into a set of RDF triples. This will be achieved by combining the use of syntactic analyzers and name entity identifiers.
This project aims to provide Virtual FPGA simulations using VIZ Feature on Microchip to offer an easy path for the migration of physical lab classes by mimicking the physical lab experience. The ability to configure the FPGA's hardware, reconfigure it when needed and optimize it for a particular set of functions makes the FPGA an attractive option in many applications. Over the next few months, in Google Summer of Code, I provide support for FPGA visualizations and increase the scope and applicability of Makerchip in FPGA simulations.
This is a proposal to add serialization and deserialization support for TOML in the functional configuration language Dhall. TOML is a relatively new configuration language that is easily human readable, supports dates and times, and is unambiguous. The biggest users of TOML are Rust’s Cargo, and consequently many Rust programs read TOML. Adding support for TOML in Dhall would mean users do not have to choose between readability and the power to program their configurations.
The goal of this project is to improve performance and provide more necessary features for Casbin.NET.
DeepFalcon is an ultra-fast non-parametric detector simulation package. This project aims to extend DeepFalcon by adding functionality for Graph Normalizing Flows (GNFs) to it.
While previous work on DeepFalcon has focused on other Deep Generative Models and Graph Neural Networks to simulate detector event reconstructions, we aim to use GNFs to create generative models for graph structures that can better approximate detector reconstructions.
MacOS, as of 2021, is not officially supported by syslog-ng. Currently, only the building and the corresponding unit tests are guaranteed on MacOS (x86 architecture) with some minor changes to the config file. However, what makes syslog-ng a better alternative is the abundance of sources/destinations and the rich filtering capabilities.
These, unfortunately, don't have any guarantee of working as extensive testing is still pending. Moreover, Apple has also introduced their in-house Apple Silicon laptops with ARM architecture, and no tests have been done on this system whatsoever.
The goal of this project is to test and document the current status of syslog-ng on MacOS and if possible, provide fixes for the same. This project seeks to extensively test multiple modules with their various plugins on both the macOS architectures. For all the plugins tested, reproducible tests and documentation will be maintained and a root cause analysis provided if a plugin fails to function.
A web based program that allows users to select a custom set of features to be included in a reduced ArduPilot firmware that uses less flash memory. The program will consist of two parts: a user interface and a backend that produces the custom build selected by the user. The interactive UI will be created by using a dynamically generated HTML web page from a Python program, and this program will also export the custom build as a downloadable ZIP file.
This proposal tackles several smaller/simpler challenges of the HosTaGe application. It focusses on addressing Logging, API Key Maintenance and improving integration with hte HPFeeds library. It further examines the GDPR implications and how a consent form can be included in the application.
This project aims to address obsolescence in the underlying RooUnfold implementation that would allow the RooUnfold package to act as a lightweight member class to ROOT whilst retaining its functionality and the ability for users to define new algorithms including machine learning based solutions, and data intensive tasks.
Patch Security Vulnerabilities Identified by NCSU
The current Django-based website for Inkscape uses Django 1.11 whose support ended in 2020. I plan to upgrade the Django version to 2.x so that ultimately it can be upgraded to 3.x.
DHIS Connector module is a module that is used to send aggregated data from OpenMRS to DHIS2 Instance. The module provides several user interfaces which can be used to configure the process easily. It already have important functionalities such as Drag-and-drop type mapping UI, Scheduled and Automated reporting, Import Export functionality for mappings, etc. The module can be improved with many other new functionalities. The project aims to develop the DHIS Connector module with new features and updates such as location mapping, extended period support, etc.
At low temperatures, many materials transition into an electronic phase which cannot be classified as a simple metal or insulator, and quantum phases of matter, like superconductors and spin liquids, are hard to study due to their fragile nature, making non-intrusive and indirect measurements important. Scientists hence use NMR (Nuclear Magnetic resonance) to probe these materials externally. NMR is an experimental technique mainly used in quality control and scientific research to determine the molecular structure, purity, and content of any sample. The GSoC project idea is to explore the connection between electronic phases and nuclei in these materials via simulations of NMR, analyze the time-evolution of nuclear spins in external magnetic pulses, and classify them using suitable Machine Learning and Deep Learning models. We also aim to optimize an applied magnetic pulse sequence to best estimate a specific physical parameter from a given material.
The Calabrese Lab 8-cell Leech Tutorial that is described by Hill et al 2001 has been a staple for teaching computational neuroscience at Emory University for many years, and it has also been used in various summer courses. This tutorial is not only a fully constructed 8-cell circuit that can generate heart rhythms, but also a great teaching tool thanks to the visual interface where a student can turn on synaptic connections or change maximal ionic conductances. However, the original tutorial has been developed using the now obsolete Genesis simulator. Unfortunately, running the Genesis simulator nowadays requires complicated software set up that prevents many non-technical students from accessing the tutorial. We had previously started porting the tutorial to a more modern format that can be executed through a web browser (see 8-cell Leech Heartbeat Network Model Tutorial), increasing the accessibility of this classic tutorial for teaching and research purposes. At this summer’s GSoC, we would like to finish this port and make the tutorial available. We selected the Neuron simulator language for running the model using NeuroML and Python as the description languages.
This project aims for improving VideoLan's crash reporter (CrashDragon) by :
Some of the plugins have security warnings that are not properly presented to the end-users. This may result in introducing security risk in existing CI/CD infrastructure.
To ensure that the given resource being deployed does not have plugins containing security issues, add a validation step using Kubernetes Admission Controller.
This GSOC will add support for the solution of a much wider class of bilevel optimization problems to JuMP. Currently, support for bilevel optimization is through BilevelJuMP.jl, which is primarily capable of solving problems for which there is a compact, strong dual for the lower-level problem. The aim of this project is to allow the integer variables and possibly even stochasticity to be included at both upper and lower levels. For this purpose, we propose two approaches. 1- Integrate the well-developed open-source solver into BilevelJuMP.jl. 2- As a stretch goal, extend Dualization.jl to include concepts from the duality of integer programming.
In this project, I will implement a new Linux kernel API to help dumping/writing back the read and write queue of UDP socket. Then I will use that new API to add UDP's read and write queue checkpoint/restore support in CRIU.
USB On-The-Go technology allows us to access different kinds of services through the USB interface. These services can be Ethernet, Serial, Mass Storage, Audio and etc. This project aims to add USB OTG support to the RTEMS Beaglebone Black BSP for Ethernet, Serial and Mass Storage Devices. This will allow RTEMS user and developer communities to easily interact with the system and use multiple services with just using a USB cable.
Develop new modules to build list and Improve/extend selection base solution infrastructure for WP1.
Package volesti provides several geometric random walks for high dimensional sampling from convex polytopes. The current implementations can be used for any logconcave distribution restricted to a convex polytope but they do not support parallel execution and sparse linear algebra computations. The aim of this project is to provide parallel implementations for all the existing random walks in volesti and efficient sparse linear algebra computations when the matrix of a polytope is sparse. I believe that this project would be of special interest for high dimensional geometric and statistical computing, e.g. in Markov Chain Monte Carlo multivariate integration, convex optimization and Bayesian inference.
Open Application Model [OAM] is a runtime-agnostic specification for defining cloud native applications and enabling building app-centric platforms by default. KubeVela is a modern application engine that adapts to your application's needs, not the other way around. KubeVela is now an standard implementation of OAM. The project is to merge OAM k8s runtime into it and make a difference on a program start option. The final goal is by completing this project, users are able to select any version they want to install.
Rocket.Chat has a remarkable internationalization effort. There are dozens of translation files across several apps, many of them with over 4000 translation strings. However, there's still a long way to go - some strings still lack translation, others need to be removed, etc. Currently, the translation process is entirely manual, making it even harder to manage that much information. To speed up the internationalization process, our goal is to build a tool that makes translators live's easier. We want to create a CLI app that helps in the translation process, answering questions like:
We want to make the actual translating easier, providing an interactive interface to add or remove translations. Our goal is to raise Rocket.Chat's translation standards - to ensure these standards are met, we'll build a CI scripts that checks for translation string usage in new contributions, ensuring every new translation string added to the codebase is listed in the translation files.
An MPD Server would be very helpful for remotely controlling the VLC Media Player. There are many great MPD Clients (including open source ones) available for many platforms, therefore one can choose a client that suits them best in order to control VLC, once a version of VLC with an MPD server is available.
The aim of my project is to make VLC a one-stop-shop for all media consumption and management on iOS.
This project is about creating a python library that implements the complete MIME Sniffing Standards.
Cilium is a networking software which provides secure network connectivity and load-balancing between applications using eBPF. In addition, Cilium is a CNI plugin for Kubernetes. Cilium can manage network access control by using network policy functions, called “CiliumNetworkPolicy” (CNP). Users can allow or deny specific traffic by applying a CNP. However, currently, any traffic except for TCP/UDP (including ICMP) is denied if an L4 CNP is present, and there is no way for the user to explicitly allow ICMP traffic. Therefore, I propose to implement a CNP for explicitly allowing ICMP traffic.
Ractor is a feature introduced in Ruby 3 that allows parallel execution. However, many Ruby libraries are currently not compatible with Ractor. This is a proposal to modify major Ruby libraries so that they can be used with Ractor.
The goal of the project is improving tracker support for custom ontologies. The goal is achieved by solving some bugs which face the application developer while building a new ontology (database schema) for his/her application.
I am aware there are many applicants, thus I sincerely apologize and regret my delay but hope I can be given an assignment/evaluation test.
I'm applying to the track for the visualisation of the MOLTO-3BP network as I am enrolled to start a graduate program in CS using distributed technology and am interested in the applications of orbital equations and computing problems.
My motivation lies in my current interest for Backend and Frontend applications as I also work with a company managing their ML algorithms for data prediction in arbitrage contexts as lead analyst and developer for the Full-stack infrastructure to support such volume and structure the visualisation process for qualitative information (as quantitative is given by volume in this case). I am now interested in leveraging such skillset to perhaps a more researching-focused world in lieu of an economic speculative industrial motivator.
I believe the 3BP is very interesting from a theoretical point of view and can be greatly improved with visual filter and newer GUI revamp to its already robust computational engine (orbital eq in the halo numerical model)
Butteraugli is a project that estimates the psychovisual similarity of two images. It gives a score for the images that is reliable in the domain of barely noticeable differences. Butteraugli not only gives a scalar score, but also computes a spatial map of the level of differences.
Butteraugli can work as a quality metric for lossy image and video compression. On our small test corpus butteraugli performs better than our implementations of the reference methods, psnrhsv-m, ssim, and our yuv-color-space variant of ssim. One possible use is to define the quality level setting used in a jpeg compressor, or to compare two or more compression methods at the same level of psychovisual differences.
Currently butterraugli is a C++ implementation and having Rust implementation of it should provide noticeable differences in terms of speed an performance, reliability & productivity. It also has:
Generating periodograms for astronomical data is the core task of Stingray. Because periodograms are often noisy, several methods to denoise periodograms exist in the literature, among them the multi-taper periodogram Stingray aims to provide a comprehensive library of reliable, well-tested implementations of common algorithms for time series analysis in Astronomy. DAVE is an elegant GUI to the library, developed during a previous GSoC.
Due to the fast-evolving Python and Javascript landscape, this GUI is not compatible with the current versions of the dependencies. Also, Stingray has now new features that were not implemented in the original GUI.
In this project, the student will refresh the GUI dependencies, update the package building infrastructure, and add the new functionality introduced in recent versions of Stingray.
During Google Summer of Code 2021, I would like to work on four new activities:
1- Mouse control action activity: its goal is to provide audio-visual feedback in a relatively meaningful way when using the mouse to help in discovering its usage for a young kid.
2- Addition decimal activity: its goal is to learn addition for decimal numbers.
3- Subtraction decimal activity: its goal is to learn subtraction for decimal numbers.
4- Programming maze loop activity: its goal is to teach the flow of For loops and While loops.
In the proposal, I have provided an implementation plan and design for each activity.
The main aim of the project is development of a new navigation menu that will aid users in navigating through the website with more ease.
Additionally, OpenWISP administration site will be modified further to enhance its appearance.
This project proposes using a Backup code to restore single-device accounts. Users have to generate the Backup code when they are already authenticated so that they can use it later. When they want to login, they can replace the TOTP/WebAuthn challenge with Backup code. For example, TOTP + password auth will be Backup code + password instead.
The Large Hadron Collider (LHC) at CERN is the world's highest energy particle accelerator, delivering the highest energy proton-proton collisions ever recorded in the laboratory, permitting a detailed exploration of elementary particle physics at the energy frontier. Simulating the particle showers and interactions in the LHC detectors is both time consuming and computationally expensive. Present fast simulation approaches based on non-parametric techniques can improve the speed of the full simulation chain but suffer from lower levels of fidelity. For this reason, alternative methods based on machine learning can provide faster solutions, while maintaining a high level of fidelity. The main goal of a fast simulator is to map the events from the generation level directly to the reconstruction level. That being said, we aim to investigate the efficiency of deep generative models in simulating event reconstructions in a given detector, hence potentially replacing conventional complex algorithms.
Creating a new cross-platform solution API from an open-sourced ML model so that developers can use the API to integrate an off-the-shelf MediaPipe Solution in their own language without requiring to compile the MediaPipe Source code with Bazel. The cross-platform API would reduce barriers to public user adoption.
Ganga is an open source job management tool for processing and bookkeeping of intensive computational tasks on a wide set of distributed resources. It effectively provides a homogeneous environment for processing data on inhomogeneous resources. It provides a simple way of preparing, organising and executing jobs on different computing infrastructures. Currently, Ganga can be accessed using an iPython prompt , file based scripting or a webGUI. GUI adds a great advantage for all the first time users of Ganga . Furthermore , the core developers and scientists can also use the GUI to get the thorough analysis of their tasks and perform their tasks with ease. The aim here is to upgrade the current GUI with new and improved functionalities. Implementation of queues, automation of connection to remote machine , interactive virtual IDE for the users, setting up the terminal inside the GUI and improving the visual aspects of the Ganga GUI are the main objectives. The major challenge of this project is to make the Ganga GUI more efficient, interactive and attractive.
Adding a modern edit buffer data structure to edwood and solving a few other issues, time permitting.
The problem of counting the linear extensions of a given partial order consists of finding (counting) all the possible ways that we can extend the partial order to a total order that preserves the original partial order. It is an important problem with various applications in Artificial Intelligence and Machine Learning, for example in partial-order plans and in learning graphical models. It is a well known #P-complete problem; the fastest known algorithms are based on dynamic programming and require exponential time and space. Nevertheless, if we only need an approximate counting attained with a probability of success, then the problem admits a polynomial-time solution for all posets using Markov chain Monte Carlo (MCMC) methods. This project aims to implement new randomized methods to approximate the number of linear extensions based on volume approximation.
Casbin is a powerful and efficient open-source access control library for Golang projects. It provides support for enforcing authorization based on various access control models. And it loads policy from persistent storage, all kinds of adapters are needed. So repository maintenance is quite important and complex. I will fix bugs which come from users using, explain user’s questions. For casbin itself, I will try my best to improve some methods’ performance and implement new features for it. For adapters, I’d like to maintain its dependency.
This proposal seeks to improve the implementation of the administration interface of the Pirania captive portal which is implemented in LibreMesh.
The goal of this project is to build a virtual file system for SQLite on top of CephFS. With that, the SQLite database can be fully distributed to obtain high-availability, horizontal scalability, better reliability and performant store.
Neuroscientists have begun to publicly share more and more datasets, however there are still barriers to making these datasets easily reusable by the community. One of these barriers has been the accessibility of shared data; it takes extensive time and effort to understand different data formats and determine which datasets are best suited for the scientific questions being asked. This project is an important step in addressing this challenge. The goal of this project is to convert publicly available datasets to the standardized NeuroData Without Borders (NWB) format so that they can be better interpreted and reused by other researchers. The data will then be made available for interactive analysis and visualization through the NWB explorer on the Open Source Brain repository. By using a standardized data format, researchers can more quickly work with new data and develop analysis methods to apply to a wide variety of datasets. The ability to easily explore and visualize data will also allow researchers to quickly assess the contents of the data and if they can reuse it. Thus, the results of this project will contribute to an important resource for scientists.
AsyncDiff is a library which compares two AsyncAPI Documents and generates diff between the two.
This project aims to bring the lagging parts of Thunar up to the modern standards. It contains a series of improvements that improve the UX and feature-completeness of Thunar.
Renovate Caya and write a libpurple plugin for it.
Alive2 is a tool that formally verifies the correctness of a subset of LLVM IR optimizations and produces counterexamples when such optimizations are incorrect. This project aims to build a similar tool for SIL.
Icecast supports writing a basic access.log that includes client information as well as connection time. An analytical interface will be implemented that will make the server and source-specific data more meaningful.
AsyncAPI offers many different ways to reuse certain parts of the document like messages or schemas definitions or references to external files, not to even mention the traits. There is a need for a tool that can be plugged into any workflows and optimize documents that are generated from code.
LLVM Project is a collection of modular and reusable compiler and toolchain technologies. It supports various high-level languages and hardware architectures. LLVM IR is an SSA-based intermediate representation whose design helps in the easy and efficient implementation of various compiler optimizations and transformations. Alive2 is a tool that checks whether the transformation of an instruction set into another instruction set is semantically correct or not. It is a verification framework for LLVM IR, which checks whether the source and target IR are equivalent or disproves by providing a counterexample. Alive2 can reason about a wide variety of intraprocedural optimization problems, including control flow, memory, vectors, and floating-point. Alive2 has detected some fundamental issues in the LLVM-IR, which lead to mis-compilation and unsound optimizations. In this project, I propose to solve some of these issues in the LLVM IR by making some changes to the LLVM compiler infrastructure code.
Icecast Server is used as a streaming server to broadcast to various listeners. A return channel allows for possibility of receiving feedback from listeners. This will make the streams interactive for conducting polls etc. The project aims to develop this return channel from listeners to source.
My Proposal is to package the Caddy Webserver for debian, including the necessary dependencies for building it, documentation, system-integration and ideally additional hardening with Apparmor.
A high priority is to also package Caddy (as its dependencies) in such way that all produced binaries are built reproducibly.
Currently back end of data provider is implemented and it supports csv,html,xml and base data provider. Many transformations are also available so that user can have a look of data after applied transformation before importing it into calc sheet.The data provider was removed in commit https://git.libreoffice.org/core/+/24939a5b43b9fe889c3aace027c668666ff61987%5E%21 because there were many issues in UI. So the aim is to improve the interface of data providers and solving issues of data transformations to bring back it into production.
Rizin currently relies upon manually writing code for adding a new CPU or an IO port. This implementation is unfit as the vast and growing ecology of hardware components such as CPUs and SoCs regularly implement a part of architecture with custom instructions, registers, and address configurations with trivial differences, making it infeasible to maintain all of them inside Rizin.
Providing a level of abstraction in handling this entropy in embedded systems, by supporting editable CPU and platform profiles is the goal of this project. This will also make adding and maintaining these ports easier with less interaction with Rizin’s core. This project also aims to add more flexibility in having a way of importing existing hardware data description documents so that reverse engineering on particular chipsets is easier. This will also help us to memory map the peripheral accesses and registers to provide a better reverse engineering experience. This, in turn, could also be extended to benefit Rizin in terms of compatibility and the end users in terms of user experience.
Using regular expressions to parse messages is very common and useful. Currently, syslog ng supports extracting fields (or name-value pairs) in its filter expressions. However, those are primarily meant for filtering and don't store extracted groups by default (despite we can manually add store-matches flags option). To make up for this deficiency, this project is to develop a new parser type, here I call it regexp-parser(). The motivation behind regexp-parser() is to remove the need to use filters to extract name-value pairs from content, which has traditionally been done by parsers. And these names can be used as user-defined macros for subsequent filtering or other types of message processing.
Improving the metric release process and fully automating will not only save time, but it will also help us to define a central structure for the current as well as upcoming WGs/metrics. Keeping in mind the ever evolving CHAOSS, the process would be scalable and flexible enough for easy tweaking in future. The quality and the impression of the PDF would also be on equal priority.
Scan8 is a scanning system for detecting trojans, viruses, malware, and other malicious threats embedded in URLs or files. The system will allow one to submit a list of URLs or files and get the scan results in return.
Scan8 will use the ClamAV open-source antivirus project as the scan engine and Google gVisor as the sandbox container which would be managed by Kubernetes.
The system will create many ClamAV containers and distribute the scan list on demand amongst them.
As mentioned in the title, I am somebody who also spends a significant amount of time on details. For example, if something is not working as expected then my first step is to question why and to pinpoint the reason. Often this requires going deep into the framework's source code and allows for innovative solutions. This interest combined with relevant experience and the desire to make a difference make me an excellent fit for your community. My background is well-rounded consisting of a profound background in machine learning, cutting-edge research, and coding of production-grade AI applications.
The projects I would like to work on in descending priority:
For more details and reasons why I am a good fit for those projects, please check out my proposal.
I want VLC to have the ability to subtitle in real-time, obviously without having subtitles available. I would therefore like to implement a Machine Learning model that can generate subtitles in real time, at least for the English language. The idea is to use a deep neural network but I am open to other alternatives.
In today’s world, a lot of educated decisions are made using the information collected by robots and are aided by the inferences given by the software agents which make use of the information collected by the other machines and robots. One such crucial field, where the software agents can contribute is “Pedestrian and Vehicle Traffic Monitoring”, where they can help us identify the hotspots and conflict zones like Pedestrian Crossings, Traffic Signals, Traffic jams, etc. The aim of this project will be to achieve this by using detection networks and depth networks or localisation/pose estimation networks or by building upon the existing functionalities like “peopleCounter_SSDCNet” components already present in the robocomp repository. Through this, the information provided by machines like RGB cameras can be exploited maximally to make better decisions based on the density of people and vehicles present in an area.
This project aims to add podcast support to Alligator. Alligator is a RSS feed reader and that makes it an ideal software for adding podcast support since both use a similar protocol. The integration will also allow users to search for new podcasts and a playlist support to queue them. The project also aims to provide integration with the Linux ecosystem using MPRIS and also to other platforms such as Android and Windows. With over 65% of listeners tuning into podcasts from portable devices the project will bring flexible improvements to the app UI focused on mobile devices while exploiting QtQuick’s support in designing convergent applications that conform the UI without increasing cognitive load on the user and provide an excellent overall experience.
The aim of this project is to create a Full-Stack web application that is capable of finding spelling mistakes that anyone across the world can use.
This project will enhance Portable Operating System Interface (POSIX) compliance in the RTEMS real-time operating system by adding newly proposed standard methods which are not currently supported in the RTEMS environment. These additions will improve RTEMS application portability, allowing for flexibility in executing on multiple platforms and assisting in ongoing technical standard conformance.
The goal of this project is to implement the IntervalLinearAlgebra.jl package within the JuliaIntervals organisation and have the first release at the end of the programme. JuliaIntervals develops packages related to interval arithmetic, a mathematical framework to perform rigorous computations, treating all quantities as intervals and producing as output of computations an interval guaranteed to contain the true result. Traditional linear algebra routines, such as solving systems of polynomial equations or even just computing the cube of a matrix have been proved to be computationally challenging and designing efficient algorithms for interval matrix computations has been an active research question for a few decades. During this project, state-of-the-art algorithms for interval linear algebra will be reviewed and implemented. As linear algebra is central in practically all numerical applications, the successful completion of the project will allow to expand interval arithmetic methods also to other domains, such as reachability analysis, optimisation and differential equations solvers.
Currently, four integration tests regarding the power policies for Chromebooks have been written using an old python-based framework called autotest. The test suite is not properly maintained for a long time and bad documentation, lack of instruction for device setup put the final nail on the coffin. The proposal is focused on reviving the integration tests for those power policies using a new framework called Tast, an integration testing system, written in Golang for chrome OS maintained by the chromium team, which also is in the active phase of development.
This proposal aims at rewriting four power policies which include USBPowershare, BatteryChargeMode, AdvancedBatteryChargeMode and PowerPeakShift.
Music Blocks is being refactored to musicblocks-v4. The current implementation of how the blocks are presented to users has several issues regarding the UI/UX and implementation of presentation of blocks. This project aims to address these issues and build upon them in the new version. This will encourage the user to build much cleaner projects and improve their project management experience.
PyZombis is a community course to teach Python to the spanish-speaking community. It is based on a brazilian MOOC Python para Zumbis. The idea is to make an improved version of the course in spanish, with an interactive environment for the students, that allows them to visualize and try active code on the site (made possible thanks to the Runestone library). Currently PyZombis is using Skulpt as its Python’s online interpreter. It has not been possible to put some of the advance PyZombis exercises interactive on the web for the students because of Skulpt limitations. It could be improved by changing the interpreter to Brython. This interpreter offers more tools as the scripting language for the Web. This is where I want to help! Also, as an extra, I can offer my help in other minor fixes in the aesthetic of the course to make it more attractive and easy-to-use for students.
Adding a graphical interface for game library management, where games are displayed with cover art thumbnails, with options for grouping and filtering by publisher, engine, and other fields.
This project has three major components: (1) Behaviour Driven Development testing notions and ideas upon being weaved into Checkstyle’s existing test driven mechanism, shall provide ease of maintenance and prevent faults as we scale the project. This will help establish testing procedures that will be concise and abstract, to focus more on the desired functionality than going into the testing algorithm. (2) With Google Truth’s new assertion framework, test verifications have become more clear, concise, flexible and readable. Migrating to Truth in Checkstyle’s tests shall be fruitful in terms of maintenance and flexibility. (3) Pitest now supports a lot of new mutators which can enhance the quality of code and coverage we currently have in the project. Adding the relevant mutators shall be another task under this project.
Convert the JSP code of virtual systems page to ReactJS Improve the UI of freshly created virtual systems page
NodeCloud is a NodeJs package that aims to provide a one-stop solution to use multiple cloud providers in a project. Currently, the node cloud project has aws, azure, and gcp integrated with an auto class generator. But for the digital ocean, this has not been implemented. Digital Ocean does not have any official SDKs but there are many third-party SDK's made by developers. Some SDKs are of no use as there are either definition files missing while some are not maintained. With this proposal, I aim to implement the important functionalities of the digital ocean in a suitable SDK(If not present) and then use that SDK to auto-generate classes for the node cloud integration
The animation portion of the MIT App Inventor, that includes the Canvas, ImageSprite and Ball components, currently has a lot of room for improvement. For the purpose of this project I propose to improve these aspects of MIT App Inventor:
The project deals with the idea of using the geometrical representation of the set of feasible portfolios, given as the intersection of the n-dimensional simplex with an n-dimensional polytope, sampling in convex polytopes using MCMC methods and development of statistical methods to describe the dependency between portfolios’ return and volatility, with the analysis of joint distribution using Copulas.
TensorMap is a visual designer for ML code. The codebase has gone stale after the initial start-up of the project. TensorMap only consists of very limited functionality at the moment. The task is to revive the project, clean up the codebase, fix the most fundamental bugs and revamp the architecture.
Implementing kernels utilizing Web-Assembly. Web-Assembly is the latest standard that enables native performance for the web. TensorFlow.js utilizes Web-Assembly to provide better CPU acceleration to a variety of devices (laptop, mobile, IoT, etc). Also, I will work on the memory footprint and debuggability of WASM.
Since, cve-bin-tool relies on contributors to build checkers for each package. This in turn requires them to know various file manipulation methods, which are easier to use on linux than on windows. To simplify this process, I propose to create a checker creation helper script, which would take .rpm, .deb, .tar.gz or other files that represent packaged versions of the software to be detected, including the product name and version number that we expect to find in each as a set of inputs. The script would automate the process mentioned in the checkers/readme.md
Recommending Safe Package Versions - Currently, cve-bin-tool outputs the vulnerable package name, version and vendor-product name. An upgrade to this would be to also provide the user with the list of all safe/fixed packages for the corresponding vulnerable packages found while scanning. This could be done by taking a vulnerable package (which was found in the scan) and web-scraping for the latest vulnerable version and then comparing it with all it’s released versions and then giving the safe version as output. An extended goal to this could be to automate the final downloading process.
Astrometry is of fundamental importance in processing astronomical data. It involves the precise measurement of the coordinates of celestial bodies. The applications range from extrasolar planet detection to tracking near-Earth objects.
The goal of the project is to get an astronomical image and convert its pixel coordinates to sky coordinates without any prior information about the input image’s location. It’s a very important feature because it allows astronomers to analyze images coming directly from telescopes as these images don’t have any information about the sky coordinates. Hence, it is the basis for almost all subsequent astrophysical analysis of the image, creating an important feature which can be used in a variety of programs
To be a reliable black-box malware analysis system DRAKVUF has to mitigate the observer effect, which can be accomplished by defeating Anti-VM-techniques. One way for the malware to determine if it is running in a sandbox environment, is to query the I/O communication port in order to identify human interaction from HID devices with the system. Until now DRAKVUF’s engine does not provide I/O-emulation, although it is needed to further camouflage its sandbox nature. Therefore an I/O-emulation module should be built to simulate a human user sitting in front of the screen and trick the malware to show its malicious behavior.
In this project, I aim to create a hin-ben repository in Apertium that also includes the task of creating/expanding the transfer rules, creating the lexical selection rules, adding several thousand (in the range of 15,000 - 20,000) words in the hin-ben bidix. I also aim to test the translator on real texts to fine-tune the translator and presenting a finished translator with a WER of less than 25%, ready for publication, at the end of the project. I will also properly document the above mentioned deliverables.
Apertium is a free and open source project. The resources generated by this project will be generally available, not just for use as a translator. There has already been some work on this language pair, but it is unfinished. This project will generate a deliverable that will be a functional machine translator. This will not only make Apertium a functional Bengali morphological analyser/generator, which can be used for other language pairs, but will also give visibility to this fact by creating a functional translator based on Bengali.
In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation. The AD library can differentiate non-trivial functions, find a partial derivative for trivial cases, and has good unit test coverage. In several cases, due to different limitations, it is either inefficient or impossible to differentiate a function, as such instead of issuing an error Clad should fall back to its future numerical differentiation abilities.
GIL is restricting Python code performance. There have been a long time that the Pythondevelopers are struggling to solve the performance issue brought byGIL. In PEP554, peoplecame up with the idea of multi-interpreter in the same program. Which can start multiple in-terpreter concurrently to solve the problem. But due to some reasons, it wasn’t be implementedin Python 3.9 Thanks to boost::asio::iocontext::strand, it’s possible for us to use multiple Python interpretersin the same program in theactor modelfashion. Hereby I propose this project to implementPython eventloop usingboost::asio::iocontext::strand Those developers who wants to use numerous Python libraries and share rich Python ecosystemwill benefit from this project.
Equadratures is a powerful open-source library assisting the user to make the use of orthogonal polynomials for uncertainty quantification, machine learning, numerical integration and dimension reduction. The upcoming version of Equadratures adds more functionalities such as plotting functions (Sobol Indices, Zonotopes), scaling functions (min-max scaling, mean-var scaling) etc. The main aim of this project is to enhance the visualization capability of Equadratures and creating an application for uncertainty quantification for computational simulation. The application would help users with no prior coding experience in python to dive deep into statistics using Equadratures. Dash framework would be used for the creation of this application. The application would provide operations for uncertainty quantification and various plotting functions helping the user to gain insights from the model.
Beagle-Config is a tool-set, that aims to provide the functionality to make the most common low-level configuration changes in beagle devices easily and providing a terminal UI to do the same as well as a host-side application for ICS and SSH within itself for continuous and seamless user experience.
LiveHD only supports glibc-based Linux at the moment. We can extend support to other platforms like Alpine Linux and macOS, so more people can use it. Alpine Linux support also allows us to compose a more lightweight container for easier and faster deployment. Additionally, the infrastructure of the LiveHD project could use some improvement, and with that, the quality of the project and the development experience can improve significantly.
Dehaze, derain, and denoise are very common image processing tasks, aiming to improve the visual quality of images. Even worse, the low-quality images will seriously influence the accuracy of many computer vision systems. There are many methods for these tasks. The guided filter is a widely known tool that shows remarkable performance for image dehazing and edge-preserving filtering. However, this tool is not supported in FFmpeg. We propose to implement the guided filter in FFmpeg, including the conventional guided filter, fast guided filter and the high-performance guided filter, such as the side-window-based guided filter and so on.
For a finite-dimensional algebra A equipped with the action of a group G, the invariant algebra A^G has many useful interpretations in topology and combinatorics. For example, when A is the cohomology ring of a topological space X and G is a covering space action, A^G is the cohomology ring of the space X/G. I aim to implement a class for computation of A^G for a generic finite-dimensional A and group G. Given a matroid M = (E,I), and a G-action on the ground set E, the Orlik-Terao algebra (OT(M)) and the Orlik-Solomon algebra (OS(M)) have a G-action induced by the action on E. Motivated by the mathematical definition of OT(M) and OS(M), I also intend to implement a class for ideals and quotients of graded supercommutative rings, using Groebner basis algorithms which are in the literature but not yet implemented in Sage. Finally, for a field k, there are canonical maps k[E] → OT(M) and Λ^k[E] → OS(M). I hope to implement coercion from the polynomial ring k[E] to OT(M) and from the exterior algebra Λ^k[E] to OS(M) and OS(M)^G.
This project aims to develop not only 3D samples using OpenGL for the OpenCV 3D module but also reusable components that can later be incorporated into the rewrite of opencv_contrib/viz module, allowing to remove the heavy VTK dependency.
CodeLabz is a platform where the users can engage with online tutorials and the organizations can create tutorials for the users. The platform is developed using ReactJS front end library and the back end is developed using the Google Cloud Firestore and Google Firebase Real-Time database. In this summer I am going to add flutter mobile app for this
To improve Librehealth Toolkit cost of care flutter application and web application which can display costs of medical procedures of US hospitals. Major improvements will be done like UI improvement, bug fix, testing and new features will be added.And some features will be added to web application which are not implemented yet.
Metal Renegades is meant to feel like an immersive Old West-style world. Right now, it’s just a desert, with some mountains made out of sand. I propose to expand that with more interesting terrain typical of the Old West: mesas where rock around a plateau has eroded away, canyons where rivers have cut deep into the rock, mountains made of rock instead of sand, and more. Additionally, I plan to create a realistic distribution of flora and fauna.
The CrawlerX is a web platform which supports crawling web URLs in a distributed way, focusing for people who are interested in data analysis, data science, Researchers, forensic authorities and etc.
OAST stands for Out-of-band Application Security Testing and is used to detect Out-Of-Band (OOB) vulnerabilities, which is not possible to do with a traditional HTTP request-response interaction. Although ZAP offers excellent DAST capabilities, it falls short when it comes to OAST.
This project aims to fill this gap. It will focus on integrating the BOAST service with ZAP via an add-on. Relevant OOB payloads sent to the target will allow BOAST to capture and process generated requests, enabling ZAP to detect and report on a new class of vulnerabilities.
Depth Estimation is one of the attractive research areas in computer vision. The motivation of this project is to estimate depth without the use of LIDAR sensors or other related costly setups. And it also makes the robot more robust and efficient to carry out any task.
This project aims at redesigning the Zulipbot, the workflow-optimizing bot by Zulip and porting it from a self-hosted web application built in NodeJS and ExpressJS to a GitHub Action built in TypeScript. This transition will make it easier for organizations and projects to use Zulipbot, with the ease of just adding a few workflow files in their repositories. It will also have the option to use custom configurations and templates on a per-repository basis.
Markdown provides a great ability to format messages and write structured documents using plain text format.
Zulip uses two different markdown processors: for the backend, it is Python-Markdown and for the frontend, it is marked.js.
While the backend markdown processor is highly extensible but the current frontend markdown processor doesn’t allow the same. Moreover, it is not upgradeable because of the Zulip customisations.
The goals of this project are:
I’ll take the reference from commonmark.js to write the CommonMark parser for our frontend-markdown processor. And to make it extensible, I'll use the upstream marked.js.
In parallel to this, I’ll focus on works in the markdown area. Integrating them with the Zulip will help to increase the overall users’ experience. The list of them are:
The project aims to improve the LLDB curses GUI to provide a complete and intuitive IDE-like debugging experience without having to resort to the command line interface.
Black Parrot is a tiny, modular Linux capable open-source processor core that encourages external contributions and strives for infrastructure agnosticism. It has been previously taped out successfully on commercial nodes TSMC 40nm and GlobalFoundaries 12nm. Last year, Google released the Google-Skywater 130nm Open-Source PDK which opened new windows in the field of Semiconductor Design and Manufacturing. To be able to successfully get a reliable, tiny, and modular Linux-capable processor like Black Parrot onto Skywater, and have it working, would be a key milestone for the open-source technology node. The aim of this project is to get a single-core implementation of Black-Parrot tapeout-ready on the Google-Skywater 130nm node.
Most of the AI researchers and developers in the field of AI wish to implement the State-of-the-art (SOTA) models as part of their research. There is an issue in that as it will take time to understand the research paper and implement the code and it will be more difficult for a beginner to implement SOTA models and research papers. Implementation of code, solving the bugs and fine-tuning should be done to develop a high performance model as a result , but all these processes are time consuming and not easy to implement in a short time . Apart from this , the models which we already owned are used in diverse fields Including image classification , object detection , segmentation etc .On the other hands developers and researchers are using this models in several hardware accelerators in IOT projects in diverse field research. The TensorFlow Model Garden will be the solution in the above situation, as it is the repository containing the code for the State-of-the-art (SOTA) models and research papers implemented with TensorFlow 2. The TensorFlow Hub contains pre-trained models that are fine-tuned and ready for the deployment.
The Audiovisual data present with Red Hen is not shareable. The visual data clearly shows the speakers involved, and a person can be recognized with the recorded audio. These datasets cannot be shared easily to protect the privacy of people. Thus, Red Hen needs an anonymization engine for its audiovisual data. Using audio processing techniques, classical computer vision algorithms and recent deep learning algorithms, we propose an anonymization engine. The engine will have a simple web-app interface, where users can choose the type of anonymization desired, or simply choose to randomly anonymize.
Postgresql allows developers more freedom to extend the provided capabilities in an application-specific manner compared to other popular open-source Relational Databases. One example of this is the ability to write user-defined functions in other languages besides SQL and C.
Julia is still a new language but with a growing community and increasing popularity due to its several strong points, among which are the Python-like straightforward syntax, speed, and interoperability with other languages.
Of course, Julia is nowhere near as established as Python (for which the PL extension is included in the standard releases of Postgresql). Still, as it becomes more widely adopted, I think that adding a more functional pl/Julia to the list of pl handlers available to developers will soon be seen as a useful contribution to the community.
In this project I will implement the tasks defined in the project description on the wiki, some of which are also listed as open issues on GitHub, namely:
Support triggers
Support event triggers
Support inline code execution, a.k.a DO statement
Support input parameters as arrays
Cache procedural language code instead of looking it up every time
The current documentation for OpenSCAD is available online at WikiBooks for easy access, which also facilitates user edits for improvisation of the manual that can be contributed to by anyone. Since we only have an online version available as of now, this creates a problem for users who do not have access to the internet at all times.
With this Project, we aim to provide an ‘offline’ version of the manual which can be generated once at the time of build and contains the whole OpenSCAD User Manual along with the OpenSCAD Language Docs.
The WikiMedia Foundation currently provides a web service named MediaWiki Action API for all the Wikimedia wikis including WikiBooks. This allows easy access to many features that WikiBooks provides including the information available at the wiki. With an API-centered approach, this project aims to provide the User with an offline copy of the docs, similar to those available online at the wiki, in HTML format, which can then be easily viewed using any installed browser, along with a pdf of the same, which also is another widely used, user-friendly file format.
Casdoor is a project established recently. For now, we need to add some features to it. Since Casoor is an authentication platform, I think we can add some features like sub users, linked accounts, to match with a variety of complex production environments.
Casnode is a forum project. It has almost all the functions that a forum should have, and is relatively perfect. At this stage, our main task is to get advice from our users and make the forum better. So I think I can fix bugs for Casnode and add features our users want. But above all, I noticed that there are still some functions displayed in the user interface that haven't been implemented. I’d like to implement them during Google Summer of Code. I am willing to follow the arrangement from the Casbin Community. I will complete the task no matter which projects are assigned to me.
My project is based on Improving FrontEnd of CodeLabs.
The idea is to ensure that all the grammar rules defined are exposed to AST level, if not then add all missing AST nodes into AST.asdl, add macros to semantics.h and use them in parser.yy. Therefore resulting in the completion of the AST generation.